jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/ValueType.java

/*******************************************************************************
 * 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 org.eclipse.jdt.core.Signature;

/**
 * Value object representing a value binding type by it's type and assignability
 * information
 * 
 * @author cbateman
 *
 */
public class ValueType implements SignatureBasedType, IAssignable
{
    /**
     * A default empty string array
     */
    protected final static String[]        EMPTY_STRING_ARRAY = new String[0];
    
    private final String        _signature;
    private final String[]      _typeArgs;
    private final int           _assignmentMask;
    private final String[]      _superTypes;
    private final String[]      _interfaceTypes;
    
    private final boolean       _isEnumType;
    
    private String[]            _allTypes;  // lazy creation on getAllTypes

    /**
     * Construct a new ValueType object with the given
     * signature
     * 
     * @param signature
     * @param typeArgs generic type arguments for signature or empty if none
     * @param superTypes 
     * @param interfaceTypes 
     * @param isEnumType 
     * @param assignmentMask 
     */
    public ValueType(final String signature,
                     final String[] typeArgs,
                     final String[] superTypes,
                     final String[] interfaceTypes,
                     final boolean  isEnumType,
                     final int assignmentMask) 
    {
        if (signature == null)
        {
            throw new AssertionError("signature can never be null"); //$NON-NLS-1$
        }
    
        _signature = signature;
        _typeArgs = typeArgs;
        _assignmentMask = assignmentMask;
        _superTypes = superTypes != null ? superTypes : EMPTY_STRING_ARRAY;
        _interfaceTypes = interfaceTypes != null ? interfaceTypes : EMPTY_STRING_ARRAY;
        _isEnumType = isEnumType;
    }
    
    /**
     * Copy constructor equivilent to 
     * ValueType(template.getSignature(), template.getSuperTypes(), template.getInterfaceTypes(),assingmentMask, template._isEnumType)
     * 
     * @param template
     * @param assignmentMask
     */
    public ValueType(final ValueType  template, final int assignmentMask)
    {
        this(template._signature, template._typeArgs, template._superTypes, 
                template._interfaceTypes, template._isEnumType, assignmentMask);
    }
    
    /**
     * Convienence constructor for creating ValueType's with no supertype, type argument
     * or interface info.  Equivilent to:
     *  ValueType(signature, new String[0], new String[0], new String[0], false, assignmentMask)
     *  
     * @param signature
     * @param assignmentMask
     */
    public ValueType(final String signature, final int assignmentMask)
    {
        this(signature, EMPTY_STRING_ARRAY, EMPTY_STRING_ARRAY, EMPTY_STRING_ARRAY, false, assignmentMask);
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.jst.jsf.core.internal.types.SignatureBasedType#getSignature()
     */
    public String getSignature() 
    {
        return _signature;
    }

    /* (non-Javadoc)
     * @see org.eclipse.jst.jsf.common.internal.types.IAssignable#getAssignability()
     */
    public int getAssignability() {
        return _assignmentMask;
    }

    /* (non-Javadoc)
     * @see org.eclipse.jst.jsf.common.internal.types.IAssignable#isLHS()
     */
    public boolean isLHS() {
        return TypeUtil.matchesLHS(_assignmentMask);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jst.jsf.common.internal.types.IAssignable#isRHS()
     */
    public boolean isRHS() {
        return TypeUtil.matchesRHS(_assignmentMask);
    }
    
    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    public String toString()
    {
        return Signature.getSignatureSimpleName
            (TypeTransformer.transformBoxPrimitives(_signature));
    }
    
    /**
     * @return an array of all signatures of all super types or empty
     * array if there are no super types for this type
     * 
     * Note: if isArray() == true, then these are the super types of 
     * the base element
     */
    public String[] getSuperTypes()
    {
        return _superTypes;
    }
    
    /**
     * @return an array of all interfaces implemented or empty array
     * if none
     * 
     * Note: if isArray() == true, then these are the interfacess of 
     * the base element
     */
    public String[] getInterfaceTypes()
    {
        return _interfaceTypes;
    }
    
    /**
     * @return all types including the base type, super types and interface
     * types.
     * 
     * Note: if isArray() == true, then these are the super types of 
     * the base element

     */
    public String[]  getAllTypes()
    {
        if (_allTypes == null)
        {
            int numberOfTypes = 1 + _superTypes.length + _interfaceTypes.length;
            _allTypes = new String[numberOfTypes];
            _allTypes[0] = _signature;
            System.arraycopy(_superTypes, 0, _allTypes, 1, _superTypes.length);
            System.arraycopy(_interfaceTypes, 0, _allTypes, 1+_superTypes.length, _interfaceTypes.length);
        }
        return _allTypes;
    }
    
    /**
     * @return the type arguments for getSignature() if any or empty array if none
     */
    public String[] getTypeArguments()
    {
        return _typeArgs;
    }
    
    /**
     * 
     */
    public CompositeType toCompositeType() 
    {
        return new CompositeType(getAllTypes(), getAssignability());
    }

    /**
     * @param signature
     * @return true if an instance of this type would satisfy instanceof signature
     *  
     */
    public boolean isInstanceOf(final String signature)
    {
        // if this is an array, then the super types are for the base
        // type and we can't be an instance of anything but signature
        if (isArray())
        {
            return getSignature().equals(signature);
        }
        
        final String[]  allTypes = getAllTypes();
        
        for (int i = 0; i < allTypes.length; i++)
        {
            if (allTypes[i].equals(signature))
            {
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * @return true if this is an array type
     */
    public boolean isArray()
    {
        return Signature.getArrayCount(getSignature()) > 0;
    }

    /**
     * @return true if the value type represents a (>=Java5) enum type
     */
    public boolean isEnumType() {
        return _isEnumType;
    }
}