• Home
• org.eclipse.persistence
• eclipselink
• 2.4.2
• source code
• XJCJavaClassImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.eclipse.persistence.jaxb.javamodel.xjc.XJCJavaClassImpl Maven / Gradle / Ivy

/*******************************************************************************
 * Copyright (c) 2011, 2013 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
 * which accompanies this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Rick Barkhouse - 2.1 - Initial implementation
 ******************************************************************************/
package org.eclipse.persistence.jaxb.javamodel.xjc;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.persistence.dynamic.DynamicClassLoader;
import org.eclipse.persistence.exceptions.JAXBException;
import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.internal.helper.ConversionManager;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.jaxb.javamodel.JavaAnnotation;
import org.eclipse.persistence.jaxb.javamodel.JavaClass;
import org.eclipse.persistence.jaxb.javamodel.JavaConstructor;
import org.eclipse.persistence.jaxb.javamodel.JavaField;
import org.eclipse.persistence.jaxb.javamodel.JavaMethod;
import org.eclipse.persistence.jaxb.javamodel.JavaModel;
import org.eclipse.persistence.jaxb.javamodel.JavaPackage;

import com.sun.codemodel.ClassType;
import com.sun.codemodel.JAnnotationUse;
import com.sun.codemodel.JClass;
import com.sun.codemodel.JCodeModel;
import com.sun.codemodel.JDefinedClass;
import com.sun.codemodel.JFieldVar;
import com.sun.codemodel.JMethod;
import com.sun.codemodel.JMods;
import com.sun.codemodel.JPrimitiveType;
import com.sun.codemodel.JType;
import com.sun.codemodel.JTypeVar;

/**
 * INTERNAL:
 * 

 * Purpose: JavaClass implementation wrapping XJC's JDefinedClass.
 * Used when bootstrapping a DynamicJAXBContext from an XML Schema.
 * 
 *
 * 

 * Responsibilities:
 * 

 *    
Provide Class information from the underlying JDefinedClass.
 * 
 * 

 *
 * @since EclipseLink 2.1
 *
 * @see org.eclipse.persistence.jaxb.javamodel.JavaClass
 */
public class XJCJavaClassImpl implements JavaClass {

    private JDefinedClass xjcClass;
    private JCodeModel jCodeModel;
    private JavaModel javaModel;
    private boolean isArray;
    private boolean isPrimitive;

    private JavaClass arg;
    
    private DynamicClassLoader dynamicClassLoader;

    private static Field JDEFINEDCLASS_ANNOTATIONS = null;
    private static Field JDEFINEDCLASS_MODS = null;
    private static Field JDEFINEDCLASS_SUPERCLASS = null;
    private static Field JTYPEVAR_BOUND = null;
    private static final Map jPrimitiveTypes = new HashMap();
    static {
        JCodeModel tempCodeModel = new JCodeModel();
        jPrimitiveTypes.put("java.lang.Boolean", tempCodeModel.BOOLEAN);
        jPrimitiveTypes.put("java.lang.Byte", tempCodeModel.BYTE);
        jPrimitiveTypes.put("java.lang.Character", tempCodeModel.CHAR);
        jPrimitiveTypes.put("java.lang.Double", tempCodeModel.DOUBLE);
        jPrimitiveTypes.put("java.lang.Float", tempCodeModel.FLOAT);
        jPrimitiveTypes.put("java.lang.Integer", tempCodeModel.INT);
        jPrimitiveTypes.put("java.lang.Long", tempCodeModel.LONG);
        jPrimitiveTypes.put("java.lang.Short", tempCodeModel.SHORT);

        try {
            JDEFINEDCLASS_ANNOTATIONS = PrivilegedAccessHelper.getDeclaredField(JDefinedClass.class, "annotations", true);
            JDEFINEDCLASS_MODS = PrivilegedAccessHelper.getDeclaredField(JDefinedClass.class, "mods", true);
            JDEFINEDCLASS_SUPERCLASS = PrivilegedAccessHelper.getDeclaredField(JDefinedClass.class, "superClass", true);
            JTYPEVAR_BOUND = PrivilegedAccessHelper.getDeclaredField(JTypeVar.class, "bound", true);
        } catch (Exception e) {
            throw JAXBException.errorCreatingDynamicJAXBContext(e);
        }
    }

    /**
     * Construct a new instance of XJCJavaClassImpl.
     *
     * @param jDefinedClass - the XJC JDefinedClass to be wrapped.
     * @param codeModel - the XJC JCodeModel this class belongs to.
     * @param loader - the ClassLoader used to bootstrap the DynamicJAXBContext.
     */
    public XJCJavaClassImpl(JDefinedClass jDefinedClass, JCodeModel codeModel, DynamicClassLoader loader) {
        this(jDefinedClass, codeModel, loader, false, false);
    }

    /**
     * Construct a new instance of XJCJavaClassImpl.
     *
     * @param jDefinedClass - the XJC JDefinedClass to be wrapped.
     * @param codeModel - the XJC JCodeModel this class belongs to.
     * @param loader - the ClassLoader used to bootstrap the DynamicJAXBContext.
     * @param isArray - indicates that this class is an array type.
     * @param isPrimitive - indicates that this class is a primitive type.
     */
    public XJCJavaClassImpl(JDefinedClass jDefinedClass, JCodeModel codeModel, DynamicClassLoader loader, boolean isArray, boolean isPrimitive) {
        this.xjcClass = jDefinedClass;
        this.jCodeModel = codeModel;
        this.dynamicClassLoader = loader;
        this.isArray = isArray;
        this.isPrimitive = isPrimitive;
    }

    // ========================================================================

    public void setActualTypeArgument(JavaClass javaClass){
    	arg = javaClass;
    }
    
    /**
     * Return the "actual" type from a parameterized type.  For example, if this
     * JavaClass represents List<Employee, this method will return the
     * Employee JavaClass.
     *
     * @return a Collection containing the actual type's JavaClass.
     */
    public Collection getActualTypeArguments() {
    	
    	
        JTypeVar[] typeParams = xjcClass.typeParams();

        if (null == typeParams || 0 == typeParams.length ) {
        	if(arg != null){
        		java.util.List theList = new ArrayList(1);
        		theList.add(arg);
        		return theList;
        	}else{
                return new ArrayList(0);
        	}
        }

        try {
            ArrayList typeArguments = new ArrayList(1);
            JTypeVar var = typeParams[typeParams.length - 1];
            JClass xjcBoundClass = (JClass) PrivilegedAccessHelper.getValueFromField(JTYPEVAR_BOUND, var);

            JType basis = null;
            try {
                // Check to see if this type has a 'basis' field.
                // This would indicate it is a "parameterized type" (e.g. List).
                // Cannot cache this field because JNarrowedClass is a protected class.
                Field basisField = PrivilegedAccessHelper.getDeclaredField(xjcBoundClass.getClass(), "basis", true);
                basis = (JClass) PrivilegedAccessHelper.getValueFromField(basisField, xjcBoundClass);
            } catch (Exception e) {
                // "basis" field not found
            }

            JavaClass boundClass;

            if (basis != null) {
                boundClass = this.javaModel.getClass(basis.fullName());
            } else if (javaModel != null) {
                boundClass = this.javaModel.getClass(xjcBoundClass.fullName());
            } else {
                JDefinedClass c = jCodeModel._getClass(xjcBoundClass.fullName());
                boundClass = new XJCJavaClassImpl(c, jCodeModel, dynamicClassLoader);
            }

            typeArguments.add(boundClass);
            return typeArguments;
        } catch (Exception e) {
            return new ArrayList(0);
        }
    }

    /**
     * If this JavaClass is an array type, return the type of the
     * array components.
     *
     * @return JavaClass of this array's component type, or null if
     *         this is not an array type.
     */
    public JavaClass getComponentType() {
        if (!isArray()) {
            return null;
        }

        return javaModel.getClass(this.xjcClass.fullName());
    }

    /**
     * Return the JavaConstructor for this JavaClass that has the
     * provided parameter types.
     *
     * @param parameterTypes the parameter list used to identify the constructor.
     *
     * @return the JavaConstructor with the signature matching parameterTypes.
     */
    public JavaConstructor getConstructor(JavaClass[] parameterTypes) {
        JType[] xjcParameterTypes = new JType[parameterTypes.length];
        for (int i = 0; i < parameterTypes.length; i++) {
            JavaClass pType = parameterTypes[i];
            String className = pType.getQualifiedName();
            JType xjcType = null;

            if (pType.isPrimitive()) {
                xjcType = jPrimitiveTypes.get(className);
            } else {
                xjcType = jCodeModel._getClass(className);
            }
            xjcParameterTypes[i] = xjcType;
        }

        JMethod constructor = xjcClass.getConstructor(xjcParameterTypes);

        return new XJCJavaConstructorImpl(constructor, jCodeModel, dynamicClassLoader, this);
    }

    /**
     * Return all of the JavaConstructors for this JavaClass.
     *
     * @return A Collection containing this JavaClass' JavaConstructors.
     */
    @SuppressWarnings("unchecked")
    public Collection getConstructors() {
        ArrayList constructors = new ArrayList();
        Iterator it = xjcClass.constructors();

        while (it.hasNext()) {
            constructors.add(new XJCJavaConstructorImpl(it.next(), jCodeModel, dynamicClassLoader, this));
        }

        return constructors;
    }

    /**
     * Return this JavaClass' inner classes.
     *
     * @return A Collection<JavaClass> containing this JavaClass' inner classes.
     */
    public Collection getDeclaredClasses() {
        ArrayList declaredClasses = new ArrayList();

        Iterator it  = xjcClass.classes();

        while (it.hasNext()) {
            XJCJavaClassImpl dc;
            if (javaModel != null) {
                dc = (XJCJavaClassImpl) this.javaModel.getClass(it.next().fullName());
            } else {
                dc = new XJCJavaClassImpl(it.next(), jCodeModel, dynamicClassLoader);
            }
            declaredClasses.add(dc);
        }

        return declaredClasses;
    }

    /**
     * Return the declared JavaConstructor for this JavaClass that has the
     * provided parameter types.
     *
     * @param parameterTypes the parameter list used to identify the constructor.
     *
     * @return the JavaConstructor with the signature matching parameterTypes.
     */
    public JavaConstructor getDeclaredConstructor(JavaClass[] parameterTypes) {
        return getConstructor(parameterTypes);
    }

    /**
     * Return all of the declared JavaConstructors for this JavaClass.
     *
     * @return A Collection containing this JavaClass' JavaConstructors.
     */
    public Collection getDeclaredConstructors() {
        return getConstructors();
    }

    /**
     * Return the declared JavaField for this JavaClass, identified
     * by fieldName.
     *
     * @param fieldName the name of the JavaField to return.
     *
     * @return the JavaField named fieldName from this JavaClass.
     */
    public JavaField getDeclaredField(String fieldName) {
        JFieldVar xjcField = xjcClass.fields().get(fieldName);

        return new XJCJavaFieldImpl(xjcField, jCodeModel, dynamicClassLoader, this);
    }

    /**
     * Return all of the declared JavaFields for this JavaClass.
     *
     * @return A Collection containing this JavaClass' JavaFields.
     */
    public Collection getDeclaredFields() {
        Collection xjcFields = xjcClass.fields().values();
        ArrayList fields = new ArrayList(xjcFields.size());

        for (JFieldVar jField : xjcFields) {
            fields.add(new XJCJavaFieldImpl(jField, jCodeModel, dynamicClassLoader, this));
        }

        return fields;
    }

    /**
     * Return the declared JavaMethod for this JavaClass,
     * identified by name, with the signature matching args.
     *
     * @param name the name of the JavaMethod to return.
     * @param args the parameter list used to identify the method.
     *
     * @return the matching JavaMethod from this JavaClass.
     */
    public JavaMethod getDeclaredMethod(String name, JavaClass[] args) {
        return getMethod(name, args);
    }

    /**
     * Return all of the declared JavaMethods for this JavaClass.
     *
     * @return A Collection containing this JavaClass' JavaMethods.
     */
    public Collection getDeclaredMethods() {
        return getMethods();
    }

    /**
     * Return the JavaMethod for this JavaClass, identified
     * by name, with the signature matching args.
     *
     * @param name the name of the JavaMethod to return.
     * @param args the parameter list used to identify the method.
     *
     * @return the matching JavaMethod from this JavaClass.
     */
    public JavaMethod getMethod(String name, JavaClass[] args) {
        Collection xjcMethods = xjcClass.methods();

        for (JMethod xjcMethod : xjcMethods) {
            JType[] params = xjcMethod.listParamTypes();
            boolean argsAreEqual = argsAreEqual(args, params);

            if (xjcMethod.name().equals(name) && argsAreEqual) {
                return new XJCJavaMethodImpl(xjcMethod, jCodeModel, dynamicClassLoader, this);
            }
        }
        return null;
    }

    private boolean argsAreEqual(JavaClass[] elinkArgs, JType[] xjcArgs) {
        if (elinkArgs == null && xjcArgs == null) {
            return true;
        }
        if (elinkArgs != null && xjcArgs == null) {
            return false;
        }
        if (elinkArgs == null && xjcArgs != null) {
            return false;
        }
        if (elinkArgs.length != xjcArgs.length) {
            return false;
        }
        for (int i = 0; i < elinkArgs.length; i++) {
            JavaClass elinkClass = elinkArgs[i];
            JType xjcClass = xjcArgs[i];
            if (!elinkClass.getQualifiedName().equals(xjcClass.fullName())) {
                return false;
            }
        }
        return true;
    }

    /**
     * Return all of the JavaMethods for this JavaClass.
     *
     * @return A Collection containing this JavaClass' JavaMethods.
     */
    public Collection getMethods() {
        Collection xjcMethods = xjcClass.methods();
        ArrayList elinkMethods = new ArrayList(xjcMethods.size());

        for (JMethod xjcMethod : xjcMethods) {
            elinkMethods.add(new XJCJavaMethodImpl(xjcMethod, jCodeModel, dynamicClassLoader, this));
        }

        return elinkMethods;
    }

    /**
     * Returns the Java language modifiers for this JavaClass, encoded in an integer.
     *
     * @return the int representing the modifiers for this class.
     *
     * @see java.lang.reflect.Modifier
     */
    public int getModifiers() {
        JMods xjcMods = null;

        try {
            xjcMods = (JMods) PrivilegedAccessHelper.getValueFromField(JDEFINEDCLASS_MODS, xjcClass);
        } catch (Exception e) {
            return 0;
        }

        return xjcMods.getValue();
    }

    /**
     * Returns the name of this JavaClass.
     *
     * @return the String name of this JavaClass.
     */
    public String getName() {
        return getQualifiedName();
    }

    /**
     * Returns the JavaPackage that this JavaClass belongs to.
     *
     * @return the JavaPackage of this JavaClass.
     */
    public JavaPackage getPackage() {
        return new XJCJavaPackageImpl(xjcClass.getPackage(), dynamicClassLoader);
    }

    /**
     * Returns the package name of this JavaClass.
     *
     * @return the String name of this JavaClass' JavaPackage.
     */
    public String getPackageName() {
        return xjcClass._package().name();
    }

    /**
     * Returns the fully-qualified name of this JavaClass.
     *
     * @return the String name of this JavaClass.
     */
    public String getQualifiedName() {
        if(isArray) {
            if(this.isPrimitive) {
                return getPrimitiveArrayNameFor(xjcClass.fullName());
            }
            return "[L" + xjcClass.fullName();
        }
        return xjcClass.fullName();
    }

    private String getPrimitiveArrayNameFor(String fullName) {
        Class componentClass = ConversionManager.getPrimitiveClass(fullName);
        if(componentClass != null) {
            if(componentClass == ClassConstants.PBYTE) {
                return ClassConstants.APBYTE.getName();
            }
            if(componentClass == ClassConstants.PCHAR) {
                return ClassConstants.APCHAR.getName();
            }
            if(componentClass == ClassConstants.PBOOLEAN) {
                return boolean[].class.getName();
            }
            if(componentClass == ClassConstants.PDOUBLE) {
                return double[].class.getName();
            }
            if(componentClass == ClassConstants.PFLOAT) {
                return float[].class.getName();
            }
            if(componentClass == ClassConstants.PINT) {
                return int[].class.getName();
            }
            if(componentClass == ClassConstants.PLONG) {
                return long[].class.getName();
            }
            if(componentClass == ClassConstants.PSHORT) {
                return short[].class.getName();
            }
        }

        return fullName;
    }

    /**
     * Returns the raw name of this JavaClass.  Array types will
     * have "[]" appended to the name.
     *
     * @return the String raw name of this JavaClass.
     */
    public String getRawName() {
        if(isArray) {
            return xjcClass.fullName() + "[]";
        }
        return xjcClass.fullName();
    }

    /**
     * Returns the super class of this JavaClass.
     *
     * @return JavaClass representing the super class of this JavaClass.
     */
    public JavaClass getSuperclass() {
        try {
            JClass superClass = (JClass) PrivilegedAccessHelper.getValueFromField(JDEFINEDCLASS_SUPERCLASS, xjcClass);

            if (superClass instanceof JDefinedClass) {
                if (javaModel != null) {
                    return this.javaModel.getClass(superClass.fullName());
                }
                return new XJCJavaClassImpl((JDefinedClass) superClass, jCodeModel, dynamicClassLoader);
            } else {
                if (javaModel != null) {
                    return this.javaModel.getClass(superClass.fullName());
                }
                return new XJCJavaClassImpl((JDefinedClass) superClass, jCodeModel, dynamicClassLoader);
            }

        } catch (Exception e) {
            return null;
        }
    }

    public Type getGenericSuperclass() {
        return null;
    }

    /**
     * Indicates if this JavaClass has actual type arguments, i.e. is a
     * parameterized type (for example, List<Employee).
     *
     * @return true if this JavaClass is parameterized, otherwise false.
     */
    public boolean hasActualTypeArguments() {
        return xjcClass.typeParams().length > 0;
    }

    /**
     * Indicates if this JavaClass is abstract.
     *
     * @return true if this JavaClass is abstract, otherwise false.
     */
    public boolean isAbstract() {
        return xjcClass.isAbstract();
    }

    /**
     * Indicates if this JavaClass is an Annotation.
     *
     * @return true if this JavaClass is an Annotation, otherwise false.
     */
    public boolean isAnnotation() {
        return xjcClass.isAnnotationTypeDeclaration();
    }

    /**
     * Indicates if this JavaClass is an Array type.
     *
     * @return true if this JavaClass is an Array type, otherwise false.
     */
    public boolean isArray() {
        if (this.isArray) {
            return true;
        }
        return this.xjcClass.isArray();
    }

    /**
     * Indicates if this JavaClass is either the same as, or is a superclass of,
     * the javaClass argument.
     *
     * @param javaClass the Class to test.
     *
     * @return true if this JavaClass is assignable from
     *         javaClass, otherwise false.
     *
     * @see java.lang.Class#isAssignableFrom(Class)
     */
    public boolean isAssignableFrom(JavaClass javaClass) {
        if (javaClass == null) {
            return false;
        }

        XJCJavaClassImpl javaClassImpl = (XJCJavaClassImpl) javaClass;
        JClass someClass = javaClassImpl.xjcClass;

        return xjcClass.isAssignableFrom(someClass);
    }

    /**
     * Indicates if this JavaClass is an enum.
     *
     * @return true if this JavaClass is an enum, otherwise false.
     */
    public boolean isEnum() {
        return xjcClass.getClassType().equals(ClassType.ENUM);
    }

    /**
     * Indicates if this JavaClass is final.
     *
     * @return true if this JavaClass is final, otherwise false.
     */
    public boolean isFinal() {
        return Modifier.isFinal(getModifiers());
    }

    /**
     * Indicates if this JavaClass is an interface.
     *
     * @return true if this JavaClass is an interface, otherwise false.
     */
    public boolean isInterface() {
        return xjcClass.isInterface();
    }

    /**
     * Indicates if this JavaClass is an inner Class.
     *
     * @return true if this JavaClass is an inner Class, otherwise false.
     */
    public boolean isMemberClass() {
        return this.xjcClass.outer() != null;
    }

    /**
     * Indicates if this JavaClass represents a primitive type.
     *
     * @return true if this JavaClass represents a primitive type, otherwise false.
     */
    public boolean isPrimitive() {
        return false;
    }

    /**
     * Indicates if this JavaClass is private.
     *
     * @return true if this JavaClass is private, otherwise false.
     */
    public boolean isPrivate() {
        return Modifier.isPrivate(getModifiers());
    }

    /**
     * Indicates if this JavaClass is protected.
     *
     * @return true if this JavaClass is protected, otherwise false.
     */
    public boolean isProtected() {
        return Modifier.isProtected(getModifiers());
    }

    /**
     * Indicates if this JavaClass is public.
     *
     * @return true if this JavaClass is public, otherwise false.
     */
    public boolean isPublic() {
        return Modifier.isPublic(getModifiers());
    }

    /**
     * Indicates if this JavaClass is static.
     *
     * @return true if this JavaClass is static, otherwise false.
     */
    public boolean isStatic() {
        return Modifier.isStatic(getModifiers());
    }

    /**
     * Not supported.
     */
    public boolean isSynthetic() {
        throw new UnsupportedOperationException("isSynthetic");
    }

    /**
     * If this JavaClass is annotated with an Annotation matching aClass,
     * return its JavaAnnotation representation.
     *
     * @param aClass a JavaClass representing the Annotation to look for.
     *
     * @return the JavaAnnotation represented by aClass, if one exists, otherwise return null.
     */
    @SuppressWarnings("unchecked")
    public JavaAnnotation getAnnotation(JavaClass aClass) {
        if (aClass != null) {
            Collection annotations = null;
            try {
                annotations = (Collection) PrivilegedAccessHelper.getValueFromField(JDEFINEDCLASS_ANNOTATIONS, xjcClass);
            } catch (Exception e) {
            }

            if (annotations == null) {
                return null;
            }

            for (JAnnotationUse annotationUse : annotations) {
                XJCJavaAnnotationImpl xjcAnnotation = new XJCJavaAnnotationImpl(annotationUse, dynamicClassLoader);

                String myAnnotationClass = xjcAnnotation.getJavaAnnotationClass().getCanonicalName();
                String annotationClass = aClass.getQualifiedName();

                if (myAnnotationClass.equals(annotationClass)) {
                    return xjcAnnotation;
                }
            }
            // Didn't find annotation so return null
            return null;
        }
        // aClass was null so return null
        return null;
    }

    /**
     * Return all of the Annotations for this JavaClass.
     *
     * @return A Collection containing this JavaClass' JavaAnnotations.
     */
    @SuppressWarnings("unchecked")
    public Collection getAnnotations() {
        ArrayList annotationsList = new ArrayList();

        Collection annotations = null;
        try {
            annotations = (Collection) PrivilegedAccessHelper.getValueFromField(JDEFINEDCLASS_ANNOTATIONS, xjcClass);
        } catch (Exception e) {
        }

        if (annotations == null) {
            return annotationsList;
        }

        for (JAnnotationUse annotationUse : annotations) {
            XJCJavaAnnotationImpl xjcAnnotation = new XJCJavaAnnotationImpl(annotationUse, dynamicClassLoader);
            annotationsList.add(xjcAnnotation);
        }
        return annotationsList;
    }

    /**
     * Not supported.
     */
    public JavaAnnotation getDeclaredAnnotation(JavaClass arg0) {
        return getAnnotation(arg0);
    }

    /**
     * Not supported.
     */
    public Collection getDeclaredAnnotations() {
        return getAnnotations();
    }

    /**
     * Get this JavaClass' JavaModel.
     *
     * @return The JavaModel associated with this JavaClass.
     */
    public JavaModel getJavaModel() {
        return javaModel;
    }

    /**
     * Set this JavaClass' JavaModel.
     *
     * @param javaModel The JavaModel to set.
     */
    public void setJavaModel(JavaModel javaModel) {
        this.javaModel = javaModel;
    }

}