Klasse Signature

java.lang.Object
org.aspectj.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 files (i.e. files with one of the Java-like extensions) 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.

Note that the "Q", "!", "|" and "Ungültige Eingabe: "&"" formats are specific to Eclipse; the remainder are specified in the JVM spec.

Due to historical reasons Eclipse uses "|" format for Intersection and "Ungültige Eingabe: "&"" for Union which is opposite to their usage in source code.

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[]
   | "!" + TypeSignature  // capture-of ?
   | "|" + TypeSignature + (":" + TypeSignature)+ // intersection type
   | ResolvedClassTypeSignature
   | UnresolvedClassTypeSignature

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

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

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

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

 OptionalTypeParameters ::=
     "<" + FormalTypeParameterSignature+ + ">"
   |
 

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<V>;" denotes java.util.List<V> in source code
  • "<E>Ljava.util.List;" denotes <E>java.util.List in source code

The syntax for a method signature is:

 MethodSignature ::= OptionalTypeParameters + "(" + 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 Ungültige Eingabe: "&" Serializable in source code

This class provides static methods and constants only.

Note: An empty signature is considered to be syntactically incorrect. So most methods will throw an IllegalArgumentException if an empty signature is provided.

  • Feldübersicht

    Felder
    Modifizierer und Typ
    Feld
    Beschreibung
    static final int
    Kind constant for an array type signature.
    static final int
    Kind constant for a base (primitive or void) type signature.
    static final char
    Character constant indicating an array type in a signature.
    static final char
    Character constant indicating the primitive type boolean in a signature.
    static final char
    Character constant indicating the primitive type byte in a signature.
    static final char
    Character constant indicating a capture of a wildcard type in a signature.
    static final char
    Character constant indicating the primitive type char in a signature.
    static final char
    Character constant indicating the colon in a signature.
    static final char
    Character constant indicating the dollar in a signature.
    static final char
    Character constant indicating the dot in a signature.
    static final char
    Character constant indicating the primitive type double in a signature.
    static final char
    Character constant indicating an exception in a signature.
    static final char
    Character constant indicating a bound wildcard type argument in a signature with extends clause.
    static final char
    Character constant indicating the primitive type float in a signature.
    static final char
    Character constant indicating the end of a generic type list in a signature.
    static final char
    Character constant indicating the start of a formal type parameter (or type argument) list in a signature.
    static final char
    Character constant indicating the primitive type int in a signature.
    static final char
    Character constant indicating an intersection type in a signature.
    static final char
    Character constant indicating the primitive type long in a signature.
    static final char
    Character constant indicating the end of a named type in a signature.
    static final char
    Character constant indicating the end of a parameter type list in a signature.
    static final char
    Character constant indicating the start of a parameter type list in a signature.
    static final char
    Character constant indicating the start of a resolved, named type in a signature.
    static final char
    Character constant indicating the semicolon in a signature.
    static final char
    Character constant indicating the primitive type short in a signature.
    static final char
    Character constant indicating an unbound wildcard type argument in a signature.
    static final char
    Character constant indicating a bound wildcard type argument in a signature with super clause.
    static final char
    Character constant indicating the start of a resolved type variable in a signature.
    static final char
    Character constant indicating a union type in a signature.
    static final char
    Character constant indicating the start of an unresolved, named type in a signature.
    static final char
    Character constant indicating result type void in a signature.
    static final int
    Kind constant for the capture of a wildcard type signature.
    static final int
    Kind constant for a class type signature.
    static final int
    Kind constant for the intersection type signature.
    static final String
    String constant for the signature of the primitive type boolean.
    static final String
    String constant for the signature of the primitive type byte.
    static final String
    String constant for the signature of the primitive type char.
    static final String
    String constant for the signature of the primitive type double.
    static final String
    String constant for the signature of the primitive type float.
    static final String
    String constant for the signature of the primitive type int.
    static final String
    String constant for the signature of the primitive type long.
    static final String
    String constant for the signature of the primitive type short.
    static final String
    String constant for the signature of result type void.
    static final int
    Kind constant for a type variable signature.
    static final int
    Kind constant for the union type signature.
    static final int
    Kind constant for a wildcard type signature.
  • Methodenübersicht

    Modifizierer und Typ
    Methode
    Beschreibung
    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 String
    createIntersectionTypeSignature(char[][] typeSignatures)
    Creates a new intersection type signature from the given type signatures.
    static String
    Creates a new intersection type signature from the given type signatures.
    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 char[]
    createTypeParameterSignature(char[] typeParameterName, char[][] boundSignatures)
    Creates a new type parameter signature with the given name and bounds.
    static String
    createTypeParameterSignature(String typeParameterName, String[] boundSignatures)
    Creates a new type parameter signature with the given name and bounds.
    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 String
    createUnionTypeSignature(String[] typeSignatures)
    Creates a new union type signature from the given type signatures.
    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 char[][]
    getIntersectionTypeBounds(char[] intersectionTypeSignature)
    Extracts the type bounds' signatures from the given intersection type signature.
    static String[]
    getIntersectionTypeBounds(String intersectionTypeSignature)
    Extracts the type bounds' signatures from the given intersection type signature.
    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
    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[]
    getSignatureQualifier(char[] typeSignature)
    Returns package fragment of a type signature.
    static String
    Returns package fragment of a type signature.
    static char[]
    getSignatureSimpleName(char[] typeSignature)
    Returns type fragment of a type signature.
    static String
    Returns type fragment of a type signature.
    static char[]
    getSimpleName(char[] name)
    Returns the last segment of the given dot-separated qualified name.
    static String
    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[]
    Returns all segments of the given dot-separated qualified name.
    static char[][]
    getThrownExceptionTypes(char[] methodSignature)
    Extracts the thrown exception type signatures from the given method signature if any The method signature is expected to be dot-based.
    static String[]
    Extracts the thrown exception type signatures from the given method signature if any The method signature is expected to be dot-based.
    static char[][]
    getTypeArguments(char[] parameterizedTypeSignature)
    Extracts the type argument signatures from the given type signature.
    static String[]
    getTypeArguments(String parameterizedTypeSignature)
    Extracts the type argument signatures from the given type signature.
    static char[]
    getTypeErasure(char[] parameterizedTypeSignature)
    Extracts the type erasure signature from the given parameterized type signature.
    static String
    getTypeErasure(String parameterizedTypeSignature)
    Extracts the type erasure signature from the given parameterized type signature.
    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 char[][]
    getTypeParameters(char[] methodOrTypeSignature)
    Extracts the type parameter signatures from the given method or type signature.
    static String[]
    getTypeParameters(String methodOrTypeSignature)
    Extracts the type parameter signatures from the given method or type signature.
    static int
    getTypeSignatureKind(char[] typeSignature)
    Returns the kind of type signature encoded by the given string.
    static int
    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 String[]
    getUnionTypeBounds(String unionSignature)
    Extracts the type bounds' signatures from the given union type signature.
    static char[]
    removeCapture(char[] methodOrTypeSignature)
    Removes any capture information from the given type or method signature and returns the resulting signature.
    static String
    removeCapture(String methodOrTypeSignature)
    Removes any capture information from the given type or method signature and returns the resulting 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[]
    toCharArray(char[] methodSignature, char[] methodName, char[][] parameterNames, boolean fullyQualifyTypeNames, boolean includeReturnType, boolean isVargArgs)
    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.
    static String
    toString(String methodSignature, String methodName, String[] parameterNames, boolean fullyQualifyTypeNames, boolean includeReturnType, boolean isVarArgs)
    Converts the given method signature to a readable string.

    Von Klasse geerbte Methoden java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Felddetails

    • ARRAY_TYPE_SIGNATURE

      public static final int ARRAY_TYPE_SIGNATURE
      Kind constant for an array type signature.
      Seit:
      3.0
      Siehe auch:
    • BASE_TYPE_SIGNATURE

      public static final int BASE_TYPE_SIGNATURE
      Kind constant for a base (primitive or void) type signature.
      Seit:
      3.0
      Siehe auch:
    • C_ARRAY

      public static final char C_ARRAY
      Character constant indicating an array type in a signature. Value is '['.
      Siehe auch:
    • C_BOOLEAN

      public static final char C_BOOLEAN
      Character constant indicating the primitive type boolean in a signature. Value is 'Z'.
      Siehe auch:
    • C_BYTE

      public static final char C_BYTE
      Character constant indicating the primitive type byte in a signature. Value is 'B'.
      Siehe auch:
    • C_CAPTURE

      public static final char C_CAPTURE
      Character constant indicating a capture of a wildcard type in a signature. Value is '!'.
      Seit:
      3.1
      Siehe auch:
    • C_CHAR

      public static final char C_CHAR
      Character constant indicating the primitive type char in a signature. Value is 'C'.
      Siehe auch:
    • C_COLON

      public static final char C_COLON
      Character constant indicating the colon in a signature. Value is ':'.
      Seit:
      3.0
      Siehe auch:
    • C_DOLLAR

      public static final char C_DOLLAR
      Character constant indicating the dollar in a signature. Value is '$'.
      Siehe auch:
    • C_DOT

      public static final char C_DOT
      Character constant indicating the dot in a signature. Value is '.'.
      Siehe auch:
    • C_DOUBLE

      public static final char C_DOUBLE
      Character constant indicating the primitive type double in a signature. Value is 'D'.
      Siehe auch:
    • C_EXCEPTION_START

      public static final char C_EXCEPTION_START
      Character constant indicating an exception in a signature. Value is '^'.
      Seit:
      3.1
      Siehe auch:
    • C_EXTENDS

      public static final char C_EXTENDS
      Character constant indicating a bound wildcard type argument in a signature with extends clause. Value is '+'.
      Seit:
      3.1
      Siehe auch:
    • C_FLOAT

      public static final char C_FLOAT
      Character constant indicating the primitive type float in a signature. Value is 'F'.
      Siehe auch:
    • 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 '>'.
      Seit:
      3.0
      Siehe auch:
    • 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 '<'.
      Seit:
      3.0
      Siehe auch:
    • C_INT

      public static final char C_INT
      Character constant indicating the primitive type int in a signature. Value is 'I'.
      Siehe auch:
    • C_INTERSECTION

      public static final char C_INTERSECTION
      Character constant indicating an intersection type in a signature. Value is '|'.
      Seit:
      3.7.1
      Siehe auch:
    • C_UNION

      public static final char C_UNION
      Character constant indicating a union type in a signature. Value is 'Ungültige Eingabe: "&"'.
      Seit:
      3.14
      Siehe auch:
    • C_LONG

      public static final char C_LONG
      Character constant indicating the primitive type long in a signature. Value is 'J'.
      Siehe auch:
    • C_NAME_END

      public static final char C_NAME_END
      Character constant indicating the end of a named type in a signature. Value is ';'.
      Siehe auch:
    • 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 ')'.
      Siehe auch:
    • 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 '('.
      Siehe auch:
    • C_RESOLVED

      public static final char C_RESOLVED
      Character constant indicating the start of a resolved, named type in a signature. Value is 'L'.
      Siehe auch:
    • C_SEMICOLON

      public static final char C_SEMICOLON
      Character constant indicating the semicolon in a signature. Value is ';'.
      Siehe auch:
    • C_SHORT

      public static final char C_SHORT
      Character constant indicating the primitive type short in a signature. Value is 'S'.
      Siehe auch:
    • C_STAR

      public static final char C_STAR
      Character constant indicating an unbound wildcard type argument in a signature. Value is '*'.
      Seit:
      3.0
      Siehe auch:
    • C_SUPER

      public static final char C_SUPER
      Character constant indicating a bound wildcard type argument in a signature with super clause. Value is '-'.
      Seit:
      3.1
      Siehe auch:
    • 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'.
      Seit:
      3.0
      Siehe auch:
    • C_UNRESOLVED

      public static final char C_UNRESOLVED
      Character constant indicating the start of an unresolved, named type in a signature. Value is 'Q'.
      Siehe auch:
    • C_VOID

      public static final char C_VOID
      Character constant indicating result type void in a signature. Value is 'V'.
      Siehe auch:
    • CAPTURE_TYPE_SIGNATURE

      public static final int CAPTURE_TYPE_SIGNATURE
      Kind constant for the capture of a wildcard type signature.
      Seit:
      3.1
      Siehe auch:
    • CLASS_TYPE_SIGNATURE

      public static final int CLASS_TYPE_SIGNATURE
      Kind constant for a class type signature.
      Seit:
      3.0
      Siehe auch:
    • INTERSECTION_TYPE_SIGNATURE

      public static final int INTERSECTION_TYPE_SIGNATURE
      Kind constant for the intersection type signature.
      Seit:
      3.7.1
      Siehe auch:
    • UNION_TYPE_SIGNATURE

      public static final int UNION_TYPE_SIGNATURE
      Kind constant for the union type signature.
      Seit:
      3.14
      Siehe auch:
    • SIG_BOOLEAN

      public static final String SIG_BOOLEAN
      String constant for the signature of the primitive type boolean. Value is "Z".
      Siehe auch:
    • SIG_BYTE

      public static final String SIG_BYTE
      String constant for the signature of the primitive type byte. Value is "B".
      Siehe auch:
    • SIG_CHAR

      public static final String SIG_CHAR
      String constant for the signature of the primitive type char. Value is "C".
      Siehe auch:
    • SIG_DOUBLE

      public static final String SIG_DOUBLE
      String constant for the signature of the primitive type double. Value is "D".
      Siehe auch:
    • SIG_FLOAT

      public static final String SIG_FLOAT
      String constant for the signature of the primitive type float. Value is "F".
      Siehe auch:
    • SIG_INT

      public static final String SIG_INT
      String constant for the signature of the primitive type int. Value is "I".
      Siehe auch:
    • SIG_LONG

      public static final String SIG_LONG
      String constant for the signature of the primitive type long. Value is "J".
      Siehe auch:
    • SIG_SHORT

      public static final String SIG_SHORT
      String constant for the signature of the primitive type short. Value is "S".
      Siehe auch:
    • SIG_VOID

      public static final String SIG_VOID
      String constant for the signature of result type void. Value is "V".
      Siehe auch:
    • TYPE_VARIABLE_SIGNATURE

      public static final int TYPE_VARIABLE_SIGNATURE
      Kind constant for a type variable signature.
      Seit:
      3.0
      Siehe auch:
    • WILDCARD_TYPE_SIGNATURE

      public static final int WILDCARD_TYPE_SIGNATURE
      Kind constant for a wildcard type signature.
      Seit:
      3.1
      Siehe auch:
  • Methodendetails

    • 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.
      Parameter:
      typeSignature - the type signature
      arrayCount - the desired number of levels of array nesting
      Gibt zurück:
      the encoded array type signature
      Seit:
      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.
      Parameter:
      typeSignature - the type signature
      arrayCount - the desired number of levels of array nesting
      Gibt zurück:
      the encoded array type signature
    • 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 or parameterized types or represent an intersection type in source code notation using &. 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.
      Parameter:
      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)
      Gibt zurück:
      the encoded type signature
      Seit:
      2.0
      Siehe auch:
    • createIntersectionTypeSignature

      public static String createIntersectionTypeSignature(char[][] typeSignatures)
      Creates a new intersection type signature from the given type signatures.

      The encoded type signature is dot-based.

      Parameter:
      typeSignatures - the given type signatures
      Gibt zurück:
      the encoded type signature
      Seit:
      3.7.1
    • createIntersectionTypeSignature

      public static String createIntersectionTypeSignature(String[] typeSignatures)
      Creates a new intersection type signature from the given type signatures.

      The encoded type signature is dot-based.

      Parameter:
      typeSignatures - the given type signatures
      Gibt zurück:
      the encoded type signature
      Seit:
      3.7.1
    • createUnionTypeSignature

      public static String createUnionTypeSignature(String[] typeSignatures)
      Creates a new union type signature from the given type signatures.

      The encoded type signature is dot-based.

      Parameter:
      typeSignatures - the given type signatures
      Gibt zurück:
      the encoded type signature
      Seit:
      3.14
    • 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.
      Parameter:
      parameterTypes - the list of parameter type signatures
      returnType - the return type signature
      Gibt zurück:
      the encoded method signature
      Seit:
      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).
      Parameter:
      parameterTypes - the list of parameter type signatures
      returnType - the return type signature
      Gibt zurück:
      the encoded method signature
      Siehe auch:
    • createTypeParameterSignature

      public static char[] createTypeParameterSignature(char[] typeParameterName, char[][] boundSignatures)
      Creates a new type parameter signature with the given name and bounds.
      Parameter:
      typeParameterName - the type parameter name
      boundSignatures - the signatures of associated bounds or empty array if none
      Gibt zurück:
      the encoded type parameter signature
      Seit:
      3.1
    • createTypeParameterSignature

      public static String createTypeParameterSignature(String typeParameterName, String[] boundSignatures)
      Creates a new type parameter signature with the given name and bounds.
      Parameter:
      typeParameterName - the type parameter name
      boundSignatures - the signatures of associated bounds or empty array if none
      Gibt zurück:
      the encoded type parameter signature
      Seit:
      3.1
    • 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, array types or parameterized types. 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.
      Parameter:
      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)
      Gibt zurück:
      the encoded type signature
      Siehe auch:
    • 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"
       
       
      Parameter:
      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)
      Gibt zurück:
      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.
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the array nesting depth, or 0 if not an array
      Löst aus:
      IllegalArgumentException - if the signature is not syntactically correct
      Seit:
      2.0
    • getArrayCount

      public static int getArrayCount(String typeSignature) throws IllegalArgumentException
      Returns the array count (array nesting depth) of the given type signature.
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the array nesting depth, or 0 if not an array
      Löst aus:
      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'}.
       
       
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the type signature without arrays
      Löst aus:
      IllegalArgumentException - if the signature is not syntactically correct
      Seit:
      2.0
    • getElementType

      public static String getElementType(String typeSignature) throws IllegalArgumentException
      Returns the type signature without any array nesting.

      For example:

       
       getElementType("[[I") --> "I".
       
       
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the type signature without arrays
      Löst aus:
      IllegalArgumentException - if the signature is not syntactically correct
    • getIntersectionTypeBounds

      public static char[][] getIntersectionTypeBounds(char[] intersectionTypeSignature) throws IllegalArgumentException
      Extracts the type bounds' signatures from the given intersection type signature. Returns an empty array if the type signature is not an intersection type signature.
      Parameter:
      intersectionTypeSignature - the intersection type signature
      Gibt zurück:
      the signatures of the type bounds
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.7.1
    • getIntersectionTypeBounds

      public static String[] getIntersectionTypeBounds(String intersectionTypeSignature) throws IllegalArgumentException
      Extracts the type bounds' signatures from the given intersection type signature. Returns an empty array if the type signature is not an intersection type signature.
      Parameter:
      intersectionTypeSignature - the intersection type signature
      Gibt zurück:
      the signatures of the type bounds
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.7.1
    • getUnionTypeBounds

      public static String[] getUnionTypeBounds(String unionSignature) throws IllegalArgumentException
      Extracts the type bounds' signatures from the given union type signature. Returns an empty array if the type signature is not an union type signature.
      Parameter:
      unionSignature - the union type signature
      Gibt zurück:
      the signatures of the type bounds
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.14
    • getParameterCount

      public static int getParameterCount(char[] methodSignature) throws IllegalArgumentException
      Returns the number of parameter types in the given method signature.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the number of parameters
      Löst aus:
      IllegalArgumentException - if the signature is not syntactically correct
      Seit:
      2.0
    • getParameterCount

      public static int getParameterCount(String methodSignature) throws IllegalArgumentException
      Returns the number of parameter types in the given method signature.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the number of parameters
      Löst aus:
      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.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the list of parameter type signatures
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      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.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the list of parameter type signatures
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
    • 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'}
       getQualifier({'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l', '.', 'L', 'i', 's', 't', 'Ungültige Eingabe: "<"', 'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'S', 't', 'r', 'i', 'n', 'g', '>'}) -> {'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l'}
       
       
      Parameter:
      name - the name
      Gibt zurück:
      the qualifier prefix, or the empty char array if the name contains no dots
      Löst aus:
      NullPointerException - if name is null
      Seit:
      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"
       getQualifier("java.util.List<java.lang.String>") -> "java.util"
       
       
      Parameter:
      name - the name
      Gibt zurück:
      the qualifier prefix, or the empty string if the name contains no dots
      Löst aus:
      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.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the type signature of the return type
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      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.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the type signature of the return type
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
    • getSignatureQualifier

      public static char[] getSignatureQualifier(char[] typeSignature)
      Returns package fragment of a type signature. The package fragment separator must be '.' and the type fragment separator must be '$'.

      For example:

       
       getSignatureQualifier({'L', 'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l', '.', 'M', 'a', 'p', '$', 'E', 'n', 't', 'r', 'y', ';'}) -> {'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l'}
       
       
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the package fragment (separators are '.')
      Seit:
      3.1
    • getSignatureQualifier

      public static String getSignatureQualifier(String typeSignature)
      Returns package fragment of a type signature. The package fragment separator must be '.' and the type fragment separator must be '$'.

      For example:

       
       getSignatureQualifier("Ljava.util.Map$Entry") -> "java.util"
       
       
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the package fragment (separators are '.')
      Seit:
      3.1
    • getSignatureSimpleName

      public static char[] getSignatureSimpleName(char[] typeSignature)
      Returns type fragment of a type signature. The package fragment separator must be '.' and the type fragment separator must be '$'.

      For example:

       
       getSignatureSimpleName({'L', 'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l', '.', 'M', 'a', 'p', '$', 'E', 'n', 't', 'r', 'y', ';'}) -> {'M', 'a', 'p', '.', 'E', 'n', 't', 'r', 'y'}
       
       
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the type fragment (separators are '.')
      Seit:
      3.1
    • getSignatureSimpleName

      public static String getSignatureSimpleName(String typeSignature)
      Returns type fragment of a type signature. The package fragment separator must be '.' and the type fragment separator must be '$'.

      For example:

       
       getSignatureSimpleName("Ljava.util.Map$Entry") -> "Map.Entry"
       
       
      Parameter:
      typeSignature - the type signature
      Gibt zurück:
      the type fragment (separators are '.')
      Seit:
      3.1
    • 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'}
       
       
      Parameter:
      name - the name
      Gibt zurück:
      the last segment of the qualified name
      Löst aus:
      NullPointerException - if name is null
      Seit:
      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"
       
       
       getSimpleName("java.util.Map<java.lang.String, java.lang.Object>") -> "Map<String,Object>"
       
       
      Parameter:
      name - the name
      Gibt zurück:
      the last segment of the qualified name
      Löst aus:
      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({}) -> {}
       getSimpleNames({'j', 'a', 'v', 'a', '.', 'u', 't', 'i', 'l', '.', 'L', 'i', 's', 't', 'Ungültige Eingabe: "<"', 'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'S', 't', 'r', 'i', 'n', 'g', '>'}) -> {{'j', 'a', 'v', 'a'}, {'l', 'a', 'n', 'g'}, {'L', 'i', 's', 't', 'Ungültige Eingabe: "<"', 'j', 'a', 'v', 'a', '.', 'l', 'a', 'n', 'g', '.', 'S', 't', 'r', 'i', 'n', 'g'}}
       
       
      Parameter:
      name - the name
      Gibt zurück:
      the list of simple names, possibly empty
      Löst aus:
      NullPointerException - if name is null
      Seit:
      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("") -> {}
       getSimpleNames("java.util.List<java.lang.String>") ->
         {"java", "util", "List<java.lang.String>"}
       
       
      Parameter:
      name - the name
      Gibt zurück:
      the list of simple names, possibly empty
      Löst aus:
      NullPointerException - if name is null
    • getThrownExceptionTypes

      public static char[][] getThrownExceptionTypes(char[] methodSignature) throws IllegalArgumentException
      Extracts the thrown exception type signatures from the given method signature if any The method signature is expected to be dot-based.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the list of thrown exception type signatures
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • getThrownExceptionTypes

      public static String[] getThrownExceptionTypes(String methodSignature) throws IllegalArgumentException
      Extracts the thrown exception type signatures from the given method signature if any The method signature is expected to be dot-based.
      Parameter:
      methodSignature - the method signature
      Gibt zurück:
      the list of thrown exception type signatures
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • getTypeArguments

      public static char[][] getTypeArguments(char[] parameterizedTypeSignature) throws IllegalArgumentException
      Extracts the type argument signatures from the given type signature. Returns an empty array if the type signature is not a parameterized type signature.
      Parameter:
      parameterizedTypeSignature - the parameterized type signature
      Gibt zurück:
      the signatures of the type arguments
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • getTypeArguments

      public static String[] getTypeArguments(String parameterizedTypeSignature) throws IllegalArgumentException
      Extracts the type argument signatures from the given type signature. Returns an empty array if the type signature is not a parameterized type signature.
      Parameter:
      parameterizedTypeSignature - the parameterized type signature
      Gibt zurück:
      the signatures of the type arguments
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • getTypeErasure

      public static char[] getTypeErasure(char[] parameterizedTypeSignature) throws IllegalArgumentException
      Extracts the type erasure signature from the given parameterized type signature. Returns the given type signature if it is not parameterized.
      Parameter:
      parameterizedTypeSignature - the parameterized type signature
      Gibt zurück:
      the signature of the type erasure
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • getTypeErasure

      public static String getTypeErasure(String parameterizedTypeSignature) throws IllegalArgumentException
      Extracts the type erasure signature from the given parameterized type signature. Returns the given type signature if it is not parameterized.
      Parameter:
      parameterizedTypeSignature - the parameterized type signature
      Gibt zurück:
      the signature of the type erasure
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • 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.
      Parameter:
      formalTypeParameterSignature - the formal type parameter signature
      Gibt zurück:
      the (possibly empty) list of type signatures for the bounds
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      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.
      Parameter:
      formalTypeParameterSignature - the formal type parameter signature
      Gibt zurück:
      the (possibly empty) list of type signatures for the bounds
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.0
    • getTypeParameters

      public static char[][] getTypeParameters(char[] methodOrTypeSignature) throws IllegalArgumentException
      Extracts the type parameter signatures from the given method or type signature. The method or type signature is expected to be dot-based.
      Parameter:
      methodOrTypeSignature - the method or type signature
      Gibt zurück:
      the list of type parameter signatures
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • getTypeParameters

      public static String[] getTypeParameters(String methodOrTypeSignature) throws IllegalArgumentException
      Extracts the type parameter signatures from the given method or type signature. The method or type signature is expected to be dot-based.
      Parameter:
      methodOrTypeSignature - the method or type signature
      Gibt zurück:
      the list of type parameter signatures
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.1
    • getTypeSignatureKind

      public static int getTypeSignatureKind(char[] typeSignature)
      Returns the kind of type signature encoded by the given string.
      Parameter:
      typeSignature - the type signature string
      Gibt zurück:
      the kind of type signature; one of the kind constants: ARRAY_TYPE_SIGNATURE, CLASS_TYPE_SIGNATURE, BASE_TYPE_SIGNATURE, or TYPE_VARIABLE_SIGNATURE, or (since 3.1) WILDCARD_TYPE_SIGNATURE or CAPTURE_TYPE_SIGNATURE, or (since 3.7) INTERSECTION_TYPE_SIGNATURE
      Löst aus:
      IllegalArgumentException - if this is not a type signature
      Seit:
      3.0
    • getTypeSignatureKind

      public static int getTypeSignatureKind(String typeSignature)
      Returns the kind of type signature encoded by the given string.
      Parameter:
      typeSignature - the type signature string
      Gibt zurück:
      the kind of type signature; one of the kind constants: ARRAY_TYPE_SIGNATURE, CLASS_TYPE_SIGNATURE, BASE_TYPE_SIGNATURE, or TYPE_VARIABLE_SIGNATURE, or (since 3.1) WILDCARD_TYPE_SIGNATURE or CAPTURE_TYPE_SIGNATURE or (since 3.7) INTERSECTION_TYPE_SIGNATURE
      Löst aus:
      IllegalArgumentException - if this is not a type signature
      Seit:
      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.
      Parameter:
      formalTypeParameterSignature - the formal type parameter signature
      Gibt zurück:
      the name of the type variable
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.0
    • 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.
      Parameter:
      formalTypeParameterSignature - the formal type parameter signature
      Gibt zurück:
      the name of the type variable
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      3.0
    • removeCapture

      public static char[] removeCapture(char[] methodOrTypeSignature)
      Removes any capture information from the given type or method signature and returns the resulting signature. Returns the type or method signature itself if no capture information is present.

      For example (using equivalent string-based method):

       
       removeCapture("LTest<!+Ljava.lang.Throwable;>;")
       will return: "LTest<+Ljava.lang.Throwable;>;"
       
       
      Parameter:
      methodOrTypeSignature - the signature which may have been captured
      Gibt zurück:
      a new signature without capture information or the signature itself if no specific capture information is present
      Löst aus:
      NullPointerException - if methodOrTypeSignature is null
      Seit:
      3.1
    • removeCapture

      public static String removeCapture(String methodOrTypeSignature)
      Removes any capture information from the given type or method signature and returns the resulting signature. Returns the type or method signature itself if no capture information is present.

      For example:

       
       removeCapture("LTest<!+Ljava.lang.Throwable;>;")
       will return: "LTest<+Ljava.lang.Throwable;>;"
       
       
      Parameter:
      methodOrTypeSignature - the signature which may have been captured
      Gibt zurück:
      a new signature without capture information or the signature itself if no specific capture information is present
      Löst aus:
      NullPointerException - if methodOrTypeSignature is null
      Seit:
      3.1
    • 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'}
       toString({'+', 'L', 'O', 'b', 'j', 'e', 'c', 't', ';'}) -> {'?', ' ', 'e', 'x', 't', 'e', 'n', 'd', 's', ' ', 'O', 'b', 'j', 'e', 'c', '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.

      Parameter:
      signature - the type signature
      Gibt zurück:
      the string representation of the type
      Löst aus:
      IllegalArgumentException - if the signature is syntactically incorrect
      Seit:
      2.0
    • 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)"
       
       
      Parameter:
      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
      Gibt zurück:
      the char array representation of the method signature
      Löst aus:
      IllegalArgumentException - if the method signature is syntactically incorrect
      Seit:
      2.0
    • toCharArray

      public static char[] toCharArray(char[] methodSignature, char[] methodName, char[][] parameterNames, boolean fullyQualifyTypeNames, boolean includeReturnType, boolean isVargArgs)
      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)"
       
       
      Parameter:
      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
      isVargArgs - true if the last argument should be displayed as a variable argument, false otherwise.
      Gibt zurück:
      the char array representation of the method signature
      Löst aus:
      IllegalArgumentException - if the method signature is syntactically incorrect
      Seit:
      3.1
    • 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({{}}) -> {}
       
       
      Parameter:
      segments - the list of name segments, possibly empty
      Gibt zurück:
      the dot-separated qualified name, or the empty string
      Seit:
      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]) -> ""
       
       
      Parameter:
      segments - the list of name segments, possibly empty
      Gibt zurück:
      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"
       toString("+QObject;") -> "? extends Object"
       
       

      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.

      Parameter:
      signature - the type signature
      Gibt zurück:
      the string representation of the type
      Löst aus:
      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.
      Parameter:
      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
      Gibt zurück:
      the string representation of the method signature
      Siehe auch:
    • toString

      public static String toString(String methodSignature, String methodName, String[] parameterNames, boolean fullyQualifyTypeNames, boolean includeReturnType, boolean isVarArgs)
      Converts the given method signature to a readable string. The method signature is expected to be dot-based.
      Parameter:
      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
      isVarArgs - true if the last argument should be displayed as a variable argument, false otherwise
      Gibt zurück:
      the string representation of the method signature
      Seit:
      3.1
      Siehe auch: