Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse JDT Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.eclipse.jdt.core
Class Signature

    java.lang.Object
      org.eclipse.jdt.core.Signature

public final class Signature
extends Object

Provides methods for encoding and decoding type and method signature strings.

Signatures obtained from parsing source (".java") files differ subtly from ones obtained from pre-compiled binary (".class") files in class names are usually left unresolved in the former. For example, the normal resolved form of the type "String" embeds the class's package name ("Ljava.lang.String;" or "Ljava/lang/String;"), whereas the unresolved form contains only what is written "QString;".

Generic types introduce to the Java language in J2SE 1.5 add three new facets to signatures: type variables, parameterized types with type arguments, and formal type parameters. Rich signatures containing these facets only occur when dealing with code that makes overt use of the new language features. All other code, and certainly all Java code written or compiled with J2SE 1.4 or earlier, involved only simple signatures.

The syntax for a type signature is:

     TypeSignature ::=
         "B"  // byte
       | "C"  // char
       | "D"  // double
       | "F"  // float
       | "I"  // int
       | "J"  // long
       | "S"  // short
       | "V"  // void
       | "Z"  // boolean
       | "T" + Identifier + ";" // type variable
       | "[" + TypeSignature  // array X[]
       | ResolvedClassTypeSignature
       | UnresolvedClassTypeSignature

     ResolvedClassTypeSignature ::= // resolved named type (in compiled code)
         "L" + Identifier + OptionalTypeArguments
               ( ( "." | "/" ) + Identifier + OptionalTypeArguments )* + ";"

     UnresolvedClassTypeSignature ::= // unresolved named type (in source code)
         "Q" + Identifier + OptionalTypeArguments
               ( ( "." | "/" ) + Identifier + OptionalTypeArguments )* + ";"

     OptionalTypeArguments ::=
         "<" + TypeArgument+ + ">"
       |

     TypeArgument ::=
       | TypeSignature
       | "*" // wildcard ?
       | "+" TypeSignature // wildcard ? extends X
       | "-" TypeSignature // wildcard ? super X

Examples:

- `"[[I"` denotes `int[][]`
- `"Ljava.lang.String;"` denotes `java.lang.String` in compiled code
- `"QString;"` denotes `String` in source code
- `"Qjava.lang.String;"` denotes `java.lang.String` in source code
- `"[QString;"` denotes `String[]` in source code
- `"QMap<QString;*>;"` denotes `Map<String,?>` in source code
- `"Qjava.util.List<TV;>;"` denotes `java.util.List<V>` in source code

The syntax for a method signature is:

     MethodSignature ::= "(" + ParamTypeSignature* + ")" + ReturnTypeSignature
     ParamTypeSignature ::= TypeSignature
     ReturnTypeSignature ::= TypeSignature

Examples:

- `"()I"` denotes `int foo()`
- `"([Ljava.lang.String;)V"` denotes `void foo(java.lang.String[])` in compiled code
- `"(QString;)QObject;"` denotes `Object foo(String)` in source code

The syntax for a formal type parameter signature is:

     FormalTypeParameterSignature ::=
         TypeVariableName + OptionalClassBound + InterfaceBound*
     TypeVariableName ::= Identifier
     OptionalClassBound ::=
         ":"
       | ":" + TypeSignature
     InterfaceBound ::=
         ":" + TypeSignature

Examples:

- `"X:"` denotes `X`
- `"X:QReader;"` denotes `X extends Reader` in source code
- `"X:QReader;:QSerializable;"` denotes `X extends Reader & Serializable` in source code

This class provides static methods and constants only; it is not intended to be instantiated or subclassed by clients.

Field Summary
`static int` | `ARRAY_TYPE_SIGNATURE` Kind constant for an array type signature.
`static int` | `BASE_TYPE_SIGNATURE` Kind constant for a base (primitive or void) type signature.
`static char` | `C_ARRAY` Character constant indicating an array type in a signature.
`static char` | `C_BOOLEAN` Character constant indicating the primitive type boolean in a signature.
`static char` | `C_BYTE` Character constant indicating the primitive type byte in a signature.
`static char` | `C_CHAR` Character constant indicating the primitive type char in a signature.
`static char` | `C_COLON` Character constant indicating the colon in a signature.
`static char` | `C_DOLLAR` Character constant indicating the dollar in a signature.
`static char` | `C_DOT` Character constant indicating the dot in a signature.
`static char` | `C_DOUBLE` Character constant indicating the primitive type double in a signature.
`static char` | `C_FLOAT` Character constant indicating the primitive type float in a signature.
`static char` | `C_GENERIC_END` Character constant indicating the end of a generic type list in a signature.
`static char` | `C_GENERIC_START` Character constant indicating the start of a formal type parameter (or type argument) list in a signature.
`static char` | `C_INT` Character constant indicating the primitive type int in a signature.
`static char` | `C_LONG` Character constant indicating the primitive type long in a signature.
`static char` | `C_NAME_END` Character constant indicating the end of a named type in a signature.
`static char` | `C_PARAM_END` Character constant indicating the end of a parameter type list in a signature.
`static char` | `C_PARAM_START` Character constant indicating the start of a parameter type list in a signature.
`static char` | `C_RESOLVED` Character constant indicating the start of a resolved, named type in a signature.
`static char` | `C_SEMICOLON` Character constant indicating the semicolon in a signature.
`static char` | `C_SHORT` Character constant indicating the primitive type short in a signature.
`static char` | `C_STAR` Character constant indicating a wildcard type argument in a signature.
`static char` | `C_TYPE_VARIABLE` Character constant indicating the start of a resolved type variable in a signature.
`static char` | `C_UNRESOLVED` Character constant indicating the start of an unresolved, named type in a signature.
`static char` | `C_VOID` Character constant indicating result type void in a signature.
`static int` | `CLASS_TYPE_SIGNATURE` Kind constant for a class type signature.
`static String` | `SIG_BOOLEAN` String constant for the signature of the primitive type boolean.
`static String` | `SIG_BYTE` String constant for the signature of the primitive type byte.
`static String` | `SIG_CHAR` String constant for the signature of the primitive type char.
`static String` | `SIG_DOUBLE` String constant for the signature of the primitive type double.
`static String` | `SIG_FLOAT` String constant for the signature of the primitive type float.
`static String` | `SIG_INT` String constant for the signature of the primitive type int.
`static String` | `SIG_LONG` String constant for the signature of the primitive type long.
`static String` | `SIG_SHORT` String constant for the signature of the primitive type short.
`static String` | `SIG_VOID` String constant for the signature of result type void.
`static int` | `TYPE_VARIABLE_SIGNATURE` Kind constant for a type variable signature.

Method Summary
`static char[]` | `createArraySignature(char[] typeSignature, int arrayCount)` Creates a new type signature with the given amount of array nesting added to the given type signature.
`static String` | `createArraySignature(String typeSignature, int arrayCount)` Creates a new type signature with the given amount of array nesting added to the given type signature.
`static char[]` | `createCharArrayTypeSignature(char[] typeName, boolean isResolved)` Creates a new type signature from the given type name encoded as a character array.
`static char[]` | `createMethodSignature(char[][] parameterTypes, char[] returnType)` Creates a method signature from the given parameter and return type signatures.
`static String` | `createMethodSignature(String[] parameterTypes, String returnType)` Creates a method signature from the given parameter and return type signatures.
`static String` | `createTypeSignature(char[] typeName, boolean isResolved)` Creates a new type signature from the given type name encoded as a character array.
`static String` | `createTypeSignature(String typeName, boolean isResolved)` Creates a new type signature from the given type name.
`static int` | `getArrayCount(char[] typeSignature)` Returns the array count (array nesting depth) of the given type signature.
`static int` | `getArrayCount(String typeSignature)` Returns the array count (array nesting depth) of the given type signature.
`static char[]` | `getElementType(char[] typeSignature)` Returns the type signature without any array nesting.
`static String` | `getElementType(String typeSignature)` Returns the type signature without any array nesting.
`static int` | `getParameterCount(char[] methodSignature)` Returns the number of parameter types in the given method signature.
`static int` | `getParameterCount(String methodSignature)` Returns the number of parameter types in the given method signature.
`static char[][]` | `getParameterTypes(char[] methodSignature)` Extracts the parameter type signatures from the given method signature.
`static String[]` | `getParameterTypes(String methodSignature)` Extracts the parameter type signatures from the given method signature.
`static char[]` | `getQualifier(char[] name)` Returns a char array containing all but the last segment of the given dot-separated qualified name.
`static String` | `getQualifier(String name)` Returns a string containing all but the last segment of the given dot-separated qualified name.
`static char[]` | `getReturnType(char[] methodSignature)` Extracts the return type from the given method signature.
`static String` | `getReturnType(String methodSignature)` Extracts the return type from the given method signature.
`static char[]` | `getSimpleName(char[] name)` Returns the last segment of the given dot-separated qualified name.
`static String` | `getSimpleName(String name)` Returns the last segment of the given dot-separated qualified name.
`static char[][]` | `getSimpleNames(char[] name)` Returns all segments of the given dot-separated qualified name.
`static String[]` | `getSimpleNames(String name)` Returns all segments of the given dot-separated qualified name.
`static char[][]` | `getTypeParameterBounds(char[] formalTypeParameterSignature)` Extracts the class and interface bounds from the given formal type parameter signature.
`static String[]` | `getTypeParameterBounds(String formalTypeParameterSignature)` Extracts the class and interface bounds from the given formal type parameter signature.
`static int` | `getTypeSignatureKind(char[] typeSignature)` Returns the kind of type signature encoded by the given string.
`static int` | `getTypeSignatureKind(String typeSignature)` Returns the kind of type signature encoded by the given string.
`static char[]` | `getTypeVariable(char[] formalTypeParameterSignature)` Extracts the type variable name from the given formal type parameter signature.
`static String` | `getTypeVariable(String formalTypeParameterSignature)` Extracts the type variable name from the given formal type parameter signature.
`static char[]` | `toCharArray(char[] signature)` Converts the given type signature to a readable string.
`static char[]` | `toCharArray(char[] methodSignature, char[] methodName, char[][] parameterNames, boolean fullyQualifyTypeNames, boolean includeReturnType)` Converts the given method signature to a readable form.
`static char[]` | `toQualifiedName(char[][] segments)` Converts the given array of qualified name segments to a qualified name.
`static String` | `toQualifiedName(String[] segments)` Converts the given array of qualified name segments to a qualified name.
`static String` | `toString(String signature)` Converts the given type signature to a readable string.
`static String` | `toString(String methodSignature, String methodName, String[] parameterNames, boolean fullyQualifyTypeNames, boolean includeReturnType)` Converts the given method signature to a readable string.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### C_BOOLEAN

    public static final char C_BOOLEAN

  Character constant indicating the primitive type boolean in a signature. Value is `'Z'`.

  See Also:
    Constant Field Values

### C_BYTE

    public static final char C_BYTE

  Character constant indicating the primitive type byte in a signature. Value is `'B'`.

  See Also:
    Constant Field Values

### C_CHAR

    public static final char C_CHAR

  Character constant indicating the primitive type char in a signature. Value is `'C'`.

  See Also:
    Constant Field Values

### C_DOUBLE

    public static final char C_DOUBLE

  Character constant indicating the primitive type double in a signature. Value is `'D'`.

  See Also:
    Constant Field Values

### C_FLOAT

    public static final char C_FLOAT

  Character constant indicating the primitive type float in a signature. Value is `'F'`.

  See Also:
    Constant Field Values

### C_INT

    public static final char C_INT

  Character constant indicating the primitive type int in a signature. Value is `'I'`.

  See Also:
    Constant Field Values

### C_SEMICOLON

    public static final char C_SEMICOLON

  Character constant indicating the semicolon in a signature. Value is `';'`.

  See Also:
    Constant Field Values

### C_COLON

    public static final char C_COLON

  Character constant indicating the colon in a signature. Value is `':'`.

  Since:
    3.0
  See Also:
    Constant Field Values

### C_LONG

    public static final char C_LONG

  Character constant indicating the primitive type long in a signature. Value is `'J'`.

  See Also:
    Constant Field Values

### C_SHORT

    public static final char C_SHORT

  Character constant indicating the primitive type short in a signature. Value is `'S'`.

  See Also:
    Constant Field Values

### C_VOID

    public static final char C_VOID

  Character constant indicating result type void in a signature. Value is `'V'`.

  See Also:
    Constant Field Values

### C_TYPE_VARIABLE

    public static final char C_TYPE_VARIABLE

  Character constant indicating the start of a resolved type variable in a signature. Value is `'T'`.

  Since:
    3.0
  See Also:
    Constant Field Values

### C_STAR

    public static final char C_STAR

  Character constant indicating a wildcard type argument in a signature. Value is `'*'`.

  Since:
    3.0
  See Also:
    Constant Field Values

### C_DOT

    public static final char C_DOT

  Character constant indicating the dot in a signature. Value is `'.'`.

  See Also:
    Constant Field Values

### C_DOLLAR

    public static final char C_DOLLAR

  Character constant indicating the dollar in a signature. Value is `'$'`.

  See Also:
    Constant Field Values

### C_ARRAY

    public static final char C_ARRAY

  Character constant indicating an array type in a signature. Value is `'['`.

  See Also:
    Constant Field Values

### C_RESOLVED

    public static final char C_RESOLVED

  Character constant indicating the start of a resolved, named type in a signature. Value is `'L'`.

  See Also:
    Constant Field Values

### C_UNRESOLVED

    public static final char C_UNRESOLVED

  Character constant indicating the start of an unresolved, named type in a signature. Value is `'Q'`.

  See Also:
    Constant Field Values

### C_NAME_END

    public static final char C_NAME_END

  Character constant indicating the end of a named type in a signature. Value is `';'`.

  See Also:
    Constant Field Values

### C_PARAM_START

    public static final char C_PARAM_START

  Character constant indicating the start of a parameter type list in a signature. Value is `'('`.

  See Also:
    Constant Field Values

### C_PARAM_END

    public static final char C_PARAM_END

  Character constant indicating the end of a parameter type list in a signature. Value is `')'`.

  See Also:
    Constant Field Values

### C_GENERIC_START

    public static final char C_GENERIC_START

  Character constant indicating the start of a formal type parameter (or type argument) list in a signature. Value is `'<'`.

  Since:
    3.0
  See Also:
    Constant Field Values

### C_GENERIC_END

    public static final char C_GENERIC_END

  Character constant indicating the end of a generic type list in a signature. Value is `'%gt;'`.

  Since:
    3.0
  See Also:
    Constant Field Values

### SIG_BOOLEAN

    public static final String SIG_BOOLEAN

  String constant for the signature of the primitive type boolean. Value is `"Z"`.

  See Also:
    Constant Field Values

### SIG_BYTE

    public static final String SIG_BYTE

  String constant for the signature of the primitive type byte. Value is `"B"`.

  See Also:
    Constant Field Values

### SIG_CHAR

    public static final String SIG_CHAR

  String constant for the signature of the primitive type char. Value is `"C"`.

  See Also:
    Constant Field Values

### SIG_DOUBLE

    public static final String SIG_DOUBLE

  String constant for the signature of the primitive type double. Value is `"D"`.

  See Also:
    Constant Field Values

### SIG_FLOAT

    public static final String SIG_FLOAT

  String constant for the signature of the primitive type float. Value is `"F"`.

  See Also:
    Constant Field Values

### SIG_INT

    public static final String SIG_INT

  String constant for the signature of the primitive type int. Value is `"I"`.

  See Also:
    Constant Field Values

### SIG_LONG

    public static final String SIG_LONG

  String constant for the signature of the primitive type long. Value is `"J"`.

  See Also:
    Constant Field Values

### SIG_SHORT

    public static final String SIG_SHORT

  String constant for the signature of the primitive type short. Value is `"S"`.

  See Also:
    Constant Field Values

### SIG_VOID

    public static final String SIG_VOID

  String constant for the signature of result type void. Value is `"V"`.

  See Also:
    Constant Field Values

### CLASS_TYPE_SIGNATURE

    public static int CLASS_TYPE_SIGNATURE

  Kind constant for a class type signature.

  Since:
    3.0
  See Also:
    `getTypeSignatureKind(String)`

### BASE_TYPE_SIGNATURE

    public static int BASE_TYPE_SIGNATURE

  Kind constant for a base (primitive or void) type signature.

  Since:
    3.0
  See Also:
    `getTypeSignatureKind(String)`

### TYPE_VARIABLE_SIGNATURE

    public static int TYPE_VARIABLE_SIGNATURE

  Kind constant for a type variable signature.

  Since:
    3.0
  See Also:
    `getTypeSignatureKind(String)`

### ARRAY_TYPE_SIGNATURE

    public static int ARRAY_TYPE_SIGNATURE

  Kind constant for an array type signature.

  Since:
    3.0
  See Also:
    `getTypeSignatureKind(String)`

Method Detail

### createArraySignature

    public static char[] createArraySignature(char[] typeSignature,
                                              int arrayCount)

  Creates a new type signature with the given amount of array nesting added to the given type signature.

  Parameters:
    `typeSignature` - the type signature
    `arrayCount` - the desired number of levels of array nesting
  Returns:
    the encoded array type signature
  Since:
    2.0

### createArraySignature

    public static String createArraySignature(String typeSignature,
                                              int arrayCount)

  Creates a new type signature with the given amount of array nesting added to the given type signature.

  Parameters:
    `typeSignature` - the type signature
    `arrayCount` - the desired number of levels of array nesting
  Returns:
    the encoded array type signature

### createMethodSignature

    public static char[] createMethodSignature(char[][] parameterTypes,
                                               char[] returnType)

  Creates a method signature from the given parameter and return type signatures. The encoded method signature is dot-based.

  Parameters:
    `parameterTypes` - the list of parameter type signatures
    `returnType` - the return type signature
  Returns:
    the encoded method signature
  Since:
    2.0

### createMethodSignature

    public static String createMethodSignature(String[] parameterTypes,
                                               String returnType)

  Creates a method signature from the given parameter and return type signatures. The encoded method signature is dot-based. This method is equivalent to `createMethodSignature(parameterTypes, returnType)`.

  Parameters:
    `parameterTypes` - the list of parameter type signatures
    `returnType` - the return type signature
  Returns:
    the encoded method signature
  See Also:
    `createMethodSignature(char[][], char[])`

### createTypeSignature

    public static String createTypeSignature(char[] typeName,
                                             boolean isResolved)

  Creates a new type signature from the given type name encoded as a character array. The type name may contain primitive types or array types. However, parameterized types are not supported. This method is equivalent to `createTypeSignature(new String(typeName),isResolved)`, although more efficient for callers with character arrays rather than strings. If the type name is qualified, then it is expected to be dot-based.

  Parameters:
    `typeName` - the possibly qualified type name
    `isResolved` - `true` if the type name is to be considered resolved (for example, a type name from a binary class file), and `false` if the type name is to be considered unresolved (for example, a type name found in source code)
  Returns:
    the encoded type signature
  See Also:
    `createTypeSignature(java.lang.String,boolean)`

### createCharArrayTypeSignature

    public static char[] createCharArrayTypeSignature(char[] typeName,
                                                      boolean isResolved)

  Creates a new type signature from the given type name encoded as a character array. The type name may contain primitive types or array types. However, parameterized types are not supported. This method is equivalent to `createTypeSignature(new String(typeName),isResolved).toCharArray()`, although more efficient for callers with character arrays rather than strings. If the type name is qualified, then it is expected to be dot-based.

  Parameters:
    `typeName` - the possibly qualified type name
    `isResolved` - `true` if the type name is to be considered resolved (for example, a type name from a binary class file), and `false` if the type name is to be considered unresolved (for example, a type name found in source code)
  Returns:
    the encoded type signature
  Since:
    2.0
  See Also:
    `createTypeSignature(java.lang.String,boolean)`

### createTypeSignature

    public static String createTypeSignature(String typeName,
                                             boolean isResolved)

  Creates a new type signature from the given type name. If the type name is qualified, then it is expected to be dot-based. The type name may contain primitive types or array types. However, parameterized types are not supported.

  For example:

       createTypeSignature("int", hucairz) -> "I"
       createTypeSignature("java.lang.String", true) -> "Ljava.lang.String;"
       createTypeSignature("String", false) -> "QString;"
       createTypeSignature("java.lang.String", false) -> "Qjava.lang.String;"
       createTypeSignature("int []", false) -> "[I"

  Parameters:
    `typeName` - the possibly qualified type name
    `isResolved` - `true` if the type name is to be considered resolved (for example, a type name from a binary class file), and `false` if the type name is to be considered unresolved (for example, a type name found in source code)
  Returns:
    the encoded type signature

### getArrayCount

    public static int getArrayCount(char[] typeSignature)
                             throws IllegalArgumentException

  Returns the array count (array nesting depth) of the given type signature.

  Parameters:
    `typeSignature` - the type signature
  Returns:
    the array nesting depth, or 0 if not an array
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct
  Since:
    2.0

### getArrayCount

    public static int getArrayCount(String typeSignature)
                             throws IllegalArgumentException

  Returns the array count (array nesting depth) of the given type signature.

  Parameters:
    `typeSignature` - the type signature
  Returns:
    the array nesting depth, or 0 if not an array
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct

### getElementType

    public static char[] getElementType(char[] typeSignature)
                                 throws IllegalArgumentException

  Returns the type signature without any array nesting.

  For example:

       getElementType({'[', '[', 'I'}) --> {'I'}.

  Parameters:
    `typeSignature` - the type signature
  Returns:
    the type signature without arrays
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct
  Since:
    2.0

### getElementType

    public static String getElementType(String typeSignature)
                                 throws IllegalArgumentException

  Returns the type signature without any array nesting.

  For example:

       getElementType("[[I") --> "I".

  Parameters:
    `typeSignature` - the type signature
  Returns:
    the type signature without arrays
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct

### getParameterCount

    public static int getParameterCount(char[] methodSignature)
                                 throws IllegalArgumentException

  Returns the number of parameter types in the given method signature.

  Parameters:
    `methodSignature` - the method signature
  Returns:
    the number of parameters
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct
  Since:
    2.0

### getTypeSignatureKind

    public static int getTypeSignatureKind(char[] typeSignature)

  Returns the kind of type signature encoded by the given string.

  Parameters:
    `typeSignature` - the type signature string
  Returns:
    the kind of type signature; one of the kind constants: `ARRAY_TYPE_SIGNATURE`, `CLASS_TYPE_SIGNATURE`, `BASE_TYPE_SIGNATURE`, or `TYPE_VARIABLE_SIGNATURE`
  Throws:
    `IllegalArgumentException` - if this is not a type signature
  Since:
    3.0

### getTypeSignatureKind

    public static int getTypeSignatureKind(String typeSignature)

  Returns the kind of type signature encoded by the given string.

  Parameters:
    `typeSignature` - the type signature string
  Returns:
    the kind of type signature; one of the kind constants: `ARRAY_TYPE_SIGNATURE`, `CLASS_TYPE_SIGNATURE`, `BASE_TYPE_SIGNATURE`, or `TYPE_VARIABLE_SIGNATURE`
  Throws:
    `IllegalArgumentException` - if this is not a type signature
  Since:
    3.0

### getParameterCount

    public static int getParameterCount(String methodSignature)
                                 throws IllegalArgumentException

  Returns the number of parameter types in the given method signature.

  Parameters:
    `methodSignature` - the method signature
  Returns:
    the number of parameters
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct

### getParameterTypes

    public static char[][] getParameterTypes(char[] methodSignature)
                                      throws IllegalArgumentException

  Extracts the parameter type signatures from the given method signature. The method signature is expected to be dot-based.

  Parameters:
    `methodSignature` - the method signature
  Returns:
    the list of parameter type signatures
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect
  Since:
    2.0

### getParameterTypes

    public static String[] getParameterTypes(String methodSignature)
                                      throws IllegalArgumentException

  Extracts the parameter type signatures from the given method signature. The method signature is expected to be dot-based.

  Parameters:
    `methodSignature` - the method signature
  Returns:
    the list of parameter type signatures
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect

### getTypeVariable

    public static String getTypeVariable(String formalTypeParameterSignature)
                                  throws IllegalArgumentException

  Extracts the type variable name from the given formal type parameter signature. The signature is expected to be dot-based.

  Parameters:
    `formalTypeParameterSignature` - the formal type parameter signature
  Returns:
    the name of the type variable
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect
  Since:
    3.0

### getTypeVariable

    public static char[] getTypeVariable(char[] formalTypeParameterSignature)
                                  throws IllegalArgumentException

  Extracts the type variable name from the given formal type parameter signature. The signature is expected to be dot-based.

  Parameters:
    `formalTypeParameterSignature` - the formal type parameter signature
  Returns:
    the name of the type variable
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect
  Since:
    3.0

### getTypeParameterBounds

    public static char[][] getTypeParameterBounds(char[] formalTypeParameterSignature)
                                           throws IllegalArgumentException

  Extracts the class and interface bounds from the given formal type parameter signature. The class bound, if present, is listed before the interface bounds. The signature is expected to be dot-based.

  Parameters:
    `formalTypeParameterSignature` - the formal type parameter signature
  Returns:
    the (possibly empty) list of type signatures for the bounds
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect
  Since:
    3.0

### getTypeParameterBounds

    public static String[] getTypeParameterBounds(String formalTypeParameterSignature)
                                           throws IllegalArgumentException

  Extracts the class and interface bounds from the given formal type parameter signature. The class bound, if present, is listed before the interface bounds. The signature is expected to be dot-based.

  Parameters:
    `formalTypeParameterSignature` - the formal type parameter signature
  Returns:
    the (possibly empty) list of type signatures for the bounds
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect
  Since:
    3.0

### getQualifier

    public static char[] getQualifier(char[] name)

  Returns a char array containing all but the last segment of the given dot-separated qualified name. Returns the empty char array if it is not qualified.

  For example:

       getQualifier({'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'O', 'b', 'j', 'e', 'c', 't'}) -> {'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g'}
       getQualifier({'O', 'u', 't', 'e', 'r', '.', 'I', 'n', 'n', 'e', 'r'}) -> {'O', 'u', 't', 'e', 'r'}

  Parameters:
    `name` - the name
  Returns:
    the qualifier prefix, or the empty char array if the name contains no dots
  Throws:
    `NullPointerException` - if name is null
  Since:
    2.0

### getQualifier

    public static String getQualifier(String name)

  Returns a string containing all but the last segment of the given dot-separated qualified name. Returns the empty string if it is not qualified.

  For example:

       getQualifier("java.lang.Object") -> "java.lang"
       getQualifier("Outer.Inner") -> "Outer"

  Parameters:
    `name` - the name
  Returns:
    the qualifier prefix, or the empty string if the name contains no dots
  Throws:
    `NullPointerException` - if name is null

### getReturnType

    public static char[] getReturnType(char[] methodSignature)
                                throws IllegalArgumentException

  Extracts the return type from the given method signature. The method signature is expected to be dot-based.

  Parameters:
    `methodSignature` - the method signature
  Returns:
    the type signature of the return type
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect
  Since:
    2.0

### getReturnType

    public static String getReturnType(String methodSignature)
                                throws IllegalArgumentException

  Extracts the return type from the given method signature. The method signature is expected to be dot-based.

  Parameters:
    `methodSignature` - the method signature
  Returns:
    the type signature of the return type
  Throws:
    `IllegalArgumentException` - if the signature is syntactically incorrect

### getSimpleName

    public static char[] getSimpleName(char[] name)

  Returns the last segment of the given dot-separated qualified name. Returns the given name if it is not qualified.

  For example:

       getSimpleName({'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'O', 'b', 'j', 'e', 'c', 't'}) -> {'O', 'b', 'j', 'e', 'c', 't'}

  Parameters:
    `name` - the name
  Returns:
    the last segment of the qualified name
  Throws:
    `NullPointerException` - if name is null
  Since:
    2.0

### getSimpleName

    public static String getSimpleName(String name)

  Returns the last segment of the given dot-separated qualified name. Returns the given name if it is not qualified.

  For example:

       getSimpleName("java.lang.Object") -> "Object"

  Parameters:
    `name` - the name
  Returns:
    the last segment of the qualified name
  Throws:
    `NullPointerException` - if name is null

### getSimpleNames

    public static char[][] getSimpleNames(char[] name)

  Returns all segments of the given dot-separated qualified name. Returns an array with only the given name if it is not qualified. Returns an empty array if the name is empty.

  For example:

       getSimpleNames({'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'O', 'b', 'j', 'e', 'c', 't'}) -> {{'j', 'a', 'v', 'a'}, {'l', 'a', 'n', 'g'}, {'O', 'b', 'j', 'e', 'c', 't'}}
       getSimpleNames({'O', 'b', 'j', 'e', 'c', 't'}) -> {{'O', 'b', 'j', 'e', 'c', 't'}}
       getSimpleNames("") -> {}

  Parameters:
    `name` - the name
  Returns:
    the list of simple names, possibly empty
  Throws:
    `NullPointerException` - if name is null
  Since:
    2.0

### getSimpleNames

    public static String[] getSimpleNames(String name)

  Returns all segments of the given dot-separated qualified name. Returns an array with only the given name if it is not qualified. Returns an empty array if the name is empty.

  For example:

       getSimpleNames("java.lang.Object") -> {"java", "lang", "Object"}
       getSimpleNames("Object") -> {"Object"}
       getSimpleNames("") -> {}

  Parameters:
    `name` - the name
  Returns:
    the list of simple names, possibly empty
  Throws:
    `NullPointerException` - if name is null

### toCharArray

    public static char[] toCharArray(char[] methodSignature,
                                     char[] methodName,
                                     char[][] parameterNames,
                                     boolean fullyQualifyTypeNames,
                                     boolean includeReturnType)

  Converts the given method signature to a readable form. The method signature is expected to be dot-based.

  For example:

       toString("([Ljava.lang.String;)V", "main", new String[] {"args"}, false, true) -> "void main(String[] args)"

  Parameters:
    `methodSignature` - the method signature to convert
    `methodName` - the name of the method to insert in the result, or `null` if no method name is to be included
    `parameterNames` - the parameter names to insert in the result, or `null` if no parameter names are to be included; if supplied, the number of parameter names must match that of the method signature
    `fullyQualifyTypeNames` - `true` if type names should be fully qualified, and `false` to use only simple names
    `includeReturnType` - `true` if the return type is to be included
  Returns:
    the char array representation of the method signature
  Since:
    2.0

### toCharArray

    public static char[] toCharArray(char[] signature)
                              throws IllegalArgumentException

  Converts the given type signature to a readable string. The signature is expected to be dot-based.

  For example:

       toString({'[', 'L', 'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'S', 't', 'r', 'i', 'n', 'g', ';'}) -> {'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'S', 't', 'r', 'i', 'n', 'g', '[', ']'}
       toString({'I'}) -> {'i', 'n', 't'}

  Note: This method assumes that a type signature containing a `'$'` is an inner type signature. While this is correct in most cases, someone could define a non-inner type name containing a `'$'`. Handling this correctly in all cases would have required resolving the signature, which generally not feasible.

  Parameters:
    `signature` - the type signature
  Returns:
    the string representation of the type
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct
  Since:
    2.0

### toQualifiedName

    public static char[] toQualifiedName(char[][] segments)

  Converts the given array of qualified name segments to a qualified name.

  For example:

       toQualifiedName({{'j', 'a', 'v', 'a'}, {'l', 'a', 'n', 'g'}, {'O', 'b', 'j', 'e', 'c', 't'}}) -> {'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'O', 'b', 'j', 'e', 'c', 't'}
       toQualifiedName({{'O', 'b', 'j', 'e', 'c', 't'}}) -> {'O', 'b', 'j', 'e', 'c', 't'}
       toQualifiedName({{}}) -> {}

  Parameters:
    `segments` - the list of name segments, possibly empty
  Returns:
    the dot-separated qualified name, or the empty string
  Since:
    2.0

### toQualifiedName

    public static String toQualifiedName(String[] segments)

  Converts the given array of qualified name segments to a qualified name.

  For example:

       toQualifiedName(new String[] {"java", "lang", "Object"}) -> "java.lang.Object"
       toQualifiedName(new String[] {"Object"}) -> "Object"
       toQualifiedName(new String[0]) -> ""

  Parameters:
    `segments` - the list of name segments, possibly empty
  Returns:
    the dot-separated qualified name, or the empty string

### toString

    public static String toString(String signature)
                           throws IllegalArgumentException

  Converts the given type signature to a readable string. The signature is expected to be dot-based.

  For example:

       toString("[Ljava.lang.String;") -> "java.lang.String[]"
       toString("I") -> "int"

  Note: This method assumes that a type signature containing a `'$'` is an inner type signature. While this is correct in most cases, someone could define a non-inner type name containing a `'$'`. Handling this correctly in all cases would have required resolving the signature, which generally not feasible.

  Parameters:
    `signature` - the type signature
  Returns:
    the string representation of the type
  Throws:
    `IllegalArgumentException` - if the signature is not syntactically correct

### toString

    public static String toString(String methodSignature,
                                  String methodName,
                                  String[] parameterNames,
                                  boolean fullyQualifyTypeNames,
                                  boolean includeReturnType)

  Converts the given method signature to a readable string. The method signature is expected to be dot-based.

  Parameters:
    `methodSignature` - the method signature to convert
    `methodName` - the name of the method to insert in the result, or `null` if no method name is to be included
    `parameterNames` - the parameter names to insert in the result, or `null` if no parameter names are to be included; if supplied, the number of parameter names must match that of the method signature
    `fullyQualifyTypeNames` - `true` if type names should be fully qualified, and `false` to use only simple names
    `includeReturnType` - `true` if the return type is to be included
  Returns:
    the string representation of the method signature
  See Also:
    `toCharArray(char[], char[], char[][], boolean, boolean)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Eclipse JDT Release 3.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (c) IBM Corp. and others 2000, 2004. All Rights Reserved.