<s> package org . eclipse . jdt . internal . core . util ; import java . util . ArrayList ; import org . eclipse . jdt . core . Signature ; import org . eclipse . jdt . core . compiler . CharOperation ; import org . eclipse . jdt . internal . compiler . ast . Wildcard ; import org . eclipse . jdt . internal . compiler . codegen . ConstantPool ; public class KeyToSignature extends BindingKeyParser { public static final int SIGNATURE = 0 ; public static final int TYPE_ARGUMENTS = 1 ; public static final int DECLARING_TYPE = 2 ; public static final int THROWN_EXCEPTIONS = 3 ; public StringBuffer signature = new StringBuffer ( ) ; private int kind ; private ArrayList arguments = new ArrayList ( ) ; private ArrayList typeArguments = new ArrayList ( ) ; private ArrayList typeParameters = new ArrayList ( ) ; private ArrayList thrownExceptions = new ArrayList ( ) ; private int mainTypeStart = - 1 ; private int mainTypeEnd ; private int typeSigStart = - 1 ; public KeyToSignature ( BindingKeyParser parser ) { super ( parser ) ; this . kind = ( ( KeyToSignature ) parser ) . kind ; } public KeyToSignature ( String key , int kind ) { super ( key ) ; this . kind = kind ; } public void consumeArrayDimension ( char [ ] brakets ) { this . signature . append ( brakets ) ; } public void consumeBaseType ( char [ ] baseTypeSig ) { this . typeSigStart = this . signature . length ( ) ; this . signature . append ( baseTypeSig ) ; } public void consumeCapture ( int position ) { this . signature . append ( '!' ) ; this . signature . append ( ( ( KeyToSignature ) this . arguments . get ( 0 ) ) . signature ) ; } public void consumeLocalType ( char [ ] uniqueKey ) { this . signature = new StringBuffer ( ) ; uniqueKey = CharOperation . subarray ( uniqueKey , 0 , uniqueKey . length - 1 ) ; CharOperation . replace ( uniqueKey , '/' , '.' ) ; this . signature . append ( uniqueKey ) ; } public void consumeMethod ( char [ ] selector , char [ ] methodSignature ) { this . arguments = new ArrayList ( ) ; this . typeArguments = new ArrayList ( ) ; CharOperation . replace ( methodSignature , '/' , '.' ) ; switch ( this . kind ) { case SIGNATURE : this . signature = new StringBuffer ( ) ; this . signature . append ( methodSignature ) ; break ; case THROWN_EXCEPTIONS : if ( CharOperation . indexOf ( '^' , methodSignature ) > 0 ) { char [ ] [ ] types = Signature . getThrownExceptionTypes ( methodSignature ) ; int length = types . length ; for ( int i = 0 ; i < length ; i ++ ) { this . thrownExceptions . add ( new String ( types [ i ] ) ) ; } } break ; } } public void consumeMemberType ( char [ ] simpleTypeName ) { this . signature . append ( '$' ) ; this . signature . append ( simpleTypeName ) ; } public void consumePackage ( char [ ] pkgName ) { this . signature . append ( pkgName ) ; } public void consumeParameterizedGenericMethod ( ) { this . typeArguments = this . arguments ; int typeParametersSize = this . arguments . size ( ) ; if ( typeParametersSize > 0 ) { int sigLength = this . signature . length ( ) ; char [ ] methodSignature = new char [ sigLength ] ; this . signature . getChars ( 0 , sigLength , methodSignature , 0 ) ; char [ ] [ ] typeParameterSigs = Signature . getTypeParameters ( methodSignature ) ; if ( typeParameterSigs . length != typeParametersSize ) return ; this . signature = new StringBuffer ( ) ; for ( int i = 0 ; i < typeParametersSize ; i ++ ) typeParameterSigs [ i ] = CharOperation . concat ( Signature . C_TYPE_VARIABLE , Signature . getTypeVariable ( typeParameterSigs [ i ] ) , Signature . C_SEMICOLON ) ; int paramStart = CharOperation . indexOf ( Signature . C_PARAM_START , methodSignature ) ; char [ ] typeParametersString = CharOperation . subarray ( methodSignature , 0 , paramStart ) ; this . signature . append ( typeParametersString ) ; this . signature . append ( Signature . C_PARAM_START ) ; char [ ] [ ] parameters = Signature . getParameterTypes ( methodSignature ) ; for ( int i = 0 , parametersLength = parameters . length ; i < parametersLength ; i ++ ) substitute ( parameters [ i ] , typeParameterSigs , typeParametersSize ) ; this . signature . append ( Signature . C_PARAM_END ) ; char [ ] returnType = Signature . getReturnType ( methodSignature ) ; substitute ( returnType , typeParameterSigs , typeParametersSize ) ; char [ ] [ ] exceptions = Signature . getThrownExceptionTypes ( methodSignature ) ; for ( int i = 0 , exceptionsLength = exceptions . length ; i < exceptionsLength ; i ++ ) { this . signature . append ( Signature . C_EXCEPTION_START ) ; substitute ( exceptions [ i ] , typeParameterSigs , typeParametersSize ) ; } } } private void substitute ( char [ ] parameter , char [ ] [ ] typeParameterSigs , int typeParametersLength ) { for ( int i = 0 ; i < typeParametersLength ; i ++ ) { if ( CharOperation . equals ( parameter , typeParameterSigs [ i ] ) ) { String typeArgument = ( ( KeyToSignature ) this . arguments . get ( i ) ) . signature . toString ( ) ; this . signature . append ( typeArgument ) ; return ; } } int genericStart = CharOperation . indexOf ( Signature . C_GENERIC_START , parameter ) ; if ( genericStart > - 1 ) { this . signature . append ( CharOperation . subarray ( parameter , 0 , genericStart ) ) ; char [ ] [ ] parameters = Signature . getTypeArguments ( parameter ) ; this . signature . append ( Signature . C_GENERIC_START ) ; for ( int j = 0 , paramsLength = parameters . length ; j < paramsLength ; j ++ ) substitute ( parameters [ j ] , typeParameterSigs , typeParametersLength ) ; this . signature . append ( Signature . C_GENERIC_END ) ; this . signature . append ( Signature . C_SEMICOLON ) ; } else { int index = 0 ; int length = parameter . length ; loop : while ( index < length ) { char current = parameter [ index ] ; switch ( current ) { case Signature . C_CAPTURE : case Signature . C_EXTENDS : case Signature . C_SUPER : case Signature . C_ARRAY : this . signature . append ( current ) ; index ++ ; break ; default : break loop ; } } if ( index > 0 ) substitute ( CharOperation . subarray ( parameter , index , length ) , typeParameterSigs , typeParametersLength ) ; else this . signature . append ( parameter ) ; } } public void consumeParameterizedType ( char [ ] simpleTypeName , boolean isRaw ) { if ( simpleTypeName != null ) { this . signature . append ( '.' ) ; this . signature . append ( simpleTypeName ) ; } if ( ! isRaw ) { this . signature . append ( '<' ) ; int length = this . arguments . size ( ) ; for ( int i = 0 ; i < length ; i ++ ) { this . signature . append ( ( ( KeyToSignature ) this . arguments . get ( i ) ) . signature ) ; } this . signature . append ( '>' ) ; this . typeArguments = this . arguments ; this . arguments = new ArrayList ( ) ; } } public void consumeParser ( BindingKeyParser parser ) { this . arguments . add ( parser ) ; } public void consumeField ( char [ ] fieldName ) { if ( this . kind == SIGNATURE ) { this . signature = ( ( KeyToSignature ) this . arguments . get ( 0 ) ) . signature ; } } public void consumeException ( ) { int size = this . arguments . size ( ) ; if ( size > 0 ) { for ( int i = 0 ; i < size ; i ++ ) { this . thrownExceptions . add ( ( ( KeyToSignature ) this . arguments . get ( i ) ) . signature . toString ( ) ) ; } this . arguments = new ArrayList ( ) ; this . typeArguments = new ArrayList ( ) ; } } public void consumeFullyQualifiedName ( char [ ] fullyQualifiedName ) { this . typeSigStart = this . signature . length ( ) ; this . signature . append ( 'L' ) ; this . signature . append ( CharOperation . replaceOnCopy ( fullyQualifiedName , '/' , '.' ) ) ; } public void consumeSecondaryType ( char [ ] simpleTypeName ) { this . signature . append ( '~' ) ; this . mainTypeStart = this . signature . lastIndexOf ( "." ) + 1 ; if ( this . mainTypeStart == 0 ) { this . mainTypeStart = 1 ; int i = 0 ; while ( this . signature . charAt ( i ) == Signature . C_ARRAY ) { this . mainTypeStart ++ ; i ++ ; } } this . mainTypeEnd = this . signature . length ( ) ; this . signature . append ( simpleTypeName ) ; } public void consumeType ( ) { if ( this . mainTypeStart != - 1 ) { this . signature . replace ( this . mainTypeStart , this . mainTypeEnd , "" ) ; } int length = this . typeParameters . size ( ) ; if ( length > 0 ) { StringBuffer typeParametersSig = new StringBuffer ( ) ; typeParametersSig . append ( '<' ) ; for ( int i = 0 ; i < length ; i ++ ) { char [ ] typeParameterSig = Signature . createTypeParameterSignature ( ( char [ ] ) this . typeParameters . get ( i ) , new char [ ] [ ] { ConstantPool . ObjectSignature } ) ; typeParametersSig . append ( typeParameterSig ) ; } typeParametersSig . append ( '>' ) ; this . signature . insert ( this . typeSigStart , typeParametersSig . toString ( ) ) ; this . typeParameters = new ArrayList ( ) ; } this . signature . append ( ';' ) ; } public void consumeTypeParameter ( char [ ] typeParameterName ) { this . typeParameters . add ( typeParameterName ) ; } public void consumeTypeVariable ( char [ ] position , char [ ] typeVariableName ) { this . signature = new StringBuffer ( ) ; this . signature . append ( 'T' ) ; this . signature . append ( typeVariableName ) ; this . signature . append ( ';' ) ; } public void consumeTypeWithCapture ( ) { KeyToSignature keyToSignature = ( KeyToSignature ) this . arguments . get ( 0 ) ; this . signature = keyToSignature . signature ; this . arguments = keyToSignature . arguments ; this . typeArguments = keyToSignature . typeArguments ; this . thrownExceptions = keyToSignature . thrownExceptions ; } public void consumeWildCard ( int wildCardKind ) { this . signature = new StringBuffer ( ) ; switch ( wildCardKind ) { case Wildcard . UNBOUND : this . signature . append ( '*' ) ; break ; case Wildcard . EXTENDS : this . signature . append ( '+' ) ; this . signature . append ( ( ( KeyToSignature ) this . arguments . get ( 0 ) ) . signature ) ; break ; case Wildcard . SUPER : this . signature . append ( '-' ) ; this . signature . append ( ( ( KeyToSignature ) this . arguments . get ( 0 ) ) . signature ) ; break ; default : return ; } } public String [ ] getThrownExceptions ( ) { int length = this . thrownExceptions . size ( ) ; String [ ] result = new String [ length ] ; for ( int i = 0 ; i < length ; i ++ ) { result [ i ] = ( String ) this . thrownExceptions . get ( i ) ; } return result ; } public String [ ] getTypeArguments ( ) { int length = this . typeArguments . size ( ) ; String [ ] result = new String [ length ] ; for ( int i = 0 ; i < length ; i ++ ) { result [ i ] = ( ( KeyToSignature ) this . typeArguments . get ( i ) ) . signature . toString ( ) ; } return result ; } public BindingKeyParser newParser ( ) { return new KeyToSignature ( this ) ; } public String toString ( ) { return this . signature . toString ( ) ; } } </s>