/*******************************************************************************
* Copyright (c) 2006 Oracle Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Cameron Bateman/Oracle - initial API and implementation
*
********************************************************************************/
package org.eclipse.jst.jsf.common.internal.types;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.jdt.core.Signature;
/**
* Transforms one CompositeType to another according to particular
* transform rules.
*
* In general, every transformation should be of the form:
*
* CompositeType transform(CompositeType original, other inputs...);
*
* @author cbateman
*
*/
public class TypeTransformer
{
private final static Map boxConversions = new HashMap();
private final static Map unBoxConversions = new HashMap();
static
{
// see jdt.core.Signature or JVM link spec for more details
boxConversions.put("B", "Ljava.lang.Byte;"); //$NON-NLS-1$//$NON-NLS-2$
boxConversions.put("C", "Ljava.lang.Character;"); //$NON-NLS-1$ //$NON-NLS-2$
boxConversions.put("D", "Ljava.lang.Double;"); //$NON-NLS-1$ //$NON-NLS-2$
boxConversions.put("F", "Ljava.lang.Float;"); //$NON-NLS-1$ //$NON-NLS-2$
boxConversions.put("I", "Ljava.lang.Integer;"); //$NON-NLS-1$ //$NON-NLS-2$
boxConversions.put("J", "Ljava.lang.Long;"); //$NON-NLS-1$ //$NON-NLS-2$
boxConversions.put("S", "Ljava.lang.Short;"); //$NON-NLS-1$ //$NON-NLS-2$
boxConversions.put("Z", "Ljava.lang.Boolean;"); //$NON-NLS-1$ //$NON-NLS-2$
// don't box V
boxConversions.put("V", "V"); //$NON-NLS-1$ //$NON-NLS-2$
// invert hte box conversions
for (final Iterator it = boxConversions.keySet().iterator(); it.hasNext();)
{
final String newValue = (String) it.next();
final String newKey = (String) boxConversions.get(newValue);
if (unBoxConversions.put(newKey, newValue) != null)
{
// if put returns non-null then we have replaced a key
// added on a previous iteration. This implies
// that box mappings are no longer one-to-one
throw new AssertionError("Duplicated boxing value"); //$NON-NLS-1$
}
}
}
/**
* @param compositeType
* @return an equivilent form of compositeType with all primitive type
* signatures converted to their fully qualified boxed equivilent but
* otherwise unchanged.
*
* Example: J -> Ljava.lang.Long;
*/
public static CompositeType transformBoxPrimitives(CompositeType compositeType)
{
String[] signatures = compositeType.getSignatures();
String[] newsignatures = new String[signatures.length];
for (int i = 0; i < signatures.length; i++)
{
newsignatures[i] = transformBoxPrimitives(signatures[i]);
}
return new CompositeType(newsignatures, compositeType.getAssignmentTypeMask());
}
/**
* Performs boxing for a single typeSignature string
* @param curSignature
* @return the boxed signature
*/
public static String transformBoxPrimitives(final String curSignature)
{
String newSignature = curSignature;
// first determine if we have a type or method signature
try
{
int kind = Signature.getTypeSignatureKind(curSignature);
// interested in base types, since these need boxing
if (kind == Signature.BASE_TYPE_SIGNATURE)
{
// grab the box for the primitive
newSignature = (String) boxConversions.get(curSignature);
}
else if (kind == Signature.ARRAY_TYPE_SIGNATURE)
{
// check if it's array of primitives
final String baseType = Signature.getElementType(curSignature);
if (Signature.getTypeSignatureKind(baseType) == Signature.BASE_TYPE_SIGNATURE)
{
// it is, so box it
final String newBaseType = (String) boxConversions.get(baseType);
final int numBraces = Signature.getArrayCount(curSignature);
newSignature = ""; //$NON-NLS-1$
for (int j = 0; j < numBraces; j++)
{
newSignature += "["; //$NON-NLS-1$
}
newSignature += newBaseType;
}
}
}
catch (IllegalArgumentException e)
{
// signature was not a type signature, so must be a method sig
// do nothing: don't box method types
}
return newSignature;
}
/**
* Performs the exact inverse of transformBoxPrimitives -- takes all
* boxing type signatures and replaces them with their primitive equivilent
* @param compositeType
* @return a new composite with all boxed primitives unboxed
*/
public static CompositeType transformUnboxPrimitives(CompositeType compositeType)
{
String[] signatures = compositeType.getSignatures();
String[] newsignatures = new String[signatures.length];
for (int i = 0; i < signatures.length; i++)
{
newsignatures[i] = transformUnboxPrimitives(signatures[i]);
}
return new CompositeType(newsignatures, compositeType.getAssignmentTypeMask());
}
/**
* Performs unboxing for a single typeSignature string
*
* @param typeSignature
* @return the transformed signature
*/
public static String transformUnboxPrimitives(final String typeSignature)
{
String newSignature = typeSignature;
// first determine if we have a type or method signature
try
{
int kind = Signature.getTypeSignatureKind(typeSignature);
// interested in class types, since these need boxing
if (kind == Signature.CLASS_TYPE_SIGNATURE)
{
// grab the box for the primitive
String checkForUnbox = (String) unBoxConversions.get(typeSignature);
if (checkForUnbox != null)
{
newSignature = checkForUnbox;
}
}
else if (kind == Signature.ARRAY_TYPE_SIGNATURE)
{
// check if it's array of objects
final String baseType = Signature.getElementType(typeSignature);
if (Signature.getTypeSignatureKind(baseType) == Signature.CLASS_TYPE_SIGNATURE)
{
// it is, so unbox it
final String newBaseTypeCandidate = (String) unBoxConversions.get(baseType);
if (newBaseTypeCandidate != null)
{
final int numBraces = Signature.getArrayCount(typeSignature);
newSignature = ""; //$NON-NLS-1$
for (int j = 0; j < numBraces; j++)
{
newSignature += "["; //$NON-NLS-1$
}
newSignature += newBaseTypeCandidate;
}
}
}
}
catch (IllegalArgumentException e)
{
// signature was not a type signature, so must be a method sig
// do nothing: don't box method types
}
return newSignature;
}
}