JField.java

/*
 *  Copyright 2012 Chris Pheby
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.jadira.scanner.classpath.types;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javassist.bytecode.AnnotationsAttribute;
import javassist.bytecode.FieldInfo;
import javassist.bytecode.annotation.Annotation;

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;
import org.jadira.scanner.classpath.ClasspathResolver;
import org.jadira.scanner.classpath.visitor.IntrospectionVisitor;
import org.jadira.scanner.core.exception.ClasspathAccessException;

public class JField extends JVariable {

    private FieldInfo fieldInfo;
    private JClass jClass;

    protected JField(FieldInfo fieldInfo, JClass jClass, ClasspathResolver resolver) {
        super(fieldInfo.getName(), resolver);
        this.fieldInfo = fieldInfo;
        this.jClass = jClass;
    }

    public static JField getJField(FieldInfo fieldInfo, JClass jClass, ClasspathResolver resolver) {
        return new JField(fieldInfo, jClass, resolver);
    }

    @Override
    public JType getEnclosingType() {
        return jClass;
    }

    @Override
    public JType getType() throws ClasspathAccessException {

        final JType retVal;

        Class<?> clazz;
        try {
            Field field = getActualField();
            clazz = field.getType();            
        } catch (SecurityException e) {
            throw new ClasspathAccessException("Problem finding enclosing type: " + e.getMessage(), e);
        }
        if (clazz.isInterface()) {
            retVal = JInterface.getJInterface(clazz.getName(), getResolver());
        } else if (clazz.isPrimitive()) {
        	retVal = JPrimitiveClass.getJClass(clazz.getName(), getResolver());
        } else if (clazz.isArray()) {
        	retVal = JArrayClass.getJClass(clazz, getResolver());
        } else {
            retVal = JClass.getJClass(clazz.getName(), getResolver());
        }
        return retVal;
    }
    
	public Class<?> decodeFieldType(String componentType) throws ClassNotFoundException {

		char type = componentType.charAt(0);
		String fieldContent = componentType.substring(1);

		switch (type) {
		// L<classname>; reference an instance of class <classname>		
		case 'L': 
			return getResolver().loadClass(fieldContent.replace('/', '.'));
		// B byte signed byte
		case 'B': 
			return Byte.class;
		// C char Unicode character
		case 'C': 
			return Character.class;
		// D double double-precision floating-point value
		case 'D': 
			return Double.class;
		// F float single-precision floating-point value
		case 'F': 
			return Float.class;
		// I int integer
		case 'I': 
			return Integer.class;
		// J long long integer
		case 'J': 
			return Long.class;
		// S short signed short
		case 'S': 
			return Short.class;
		// Z boolean true or false
		case 'Z': 
			return Boolean.class;
		// [ reference one array dimension
		case '[': 
		    return getResolver().loadClass(componentType.replace('/', '.') + ";");
		}
		return null;
	}

    @Override
    public Set<JAnnotation<?>> getAnnotations() {

        AnnotationsAttribute visible = (AnnotationsAttribute) fieldInfo.getAttribute(AnnotationsAttribute.visibleTag);
        AnnotationsAttribute invisible = (AnnotationsAttribute) fieldInfo.getAttribute(AnnotationsAttribute.invisibleTag);

        Set<JAnnotation<?>> annotations = new HashSet<JAnnotation<?>>();

        List<Annotation> annotationsList = new ArrayList<Annotation>();
        if (visible != null) {
            annotationsList.addAll(Arrays.asList(visible.getAnnotations()));
        }
        if (invisible != null) {
            annotationsList.addAll(Arrays.asList(invisible.getAnnotations()));
        }

        for (Annotation nextAnnotation : annotationsList) {
            annotations.add(JAnnotation.getJAnnotation(nextAnnotation, this, getResolver()));
        }

        return annotations;
    }

    @Override
    public void acceptVisitor(IntrospectionVisitor visitor) {
        visitor.visit(this);

        for (JAnnotation<?> next : getAnnotations()) {
            next.acceptVisitor(visitor);
        }
    }

    public Field getActualField() {

        try {
            return getEnclosingType().getActualClass().getDeclaredField(getName());
        } catch (SecurityException e) {
            throw new ClasspathAccessException("Problem obtaining field: " + e.getMessage(), e);
        } catch (NoSuchFieldException e) {
            throw new ClasspathAccessException("Problem finding field: " + this.toString(), e);
        }
    }

    public FieldInfo getFieldInfo() {
        return fieldInfo;
    }

    @Override
    public JClass getEnclosingElement() {
        return jClass;
    }
    
    @Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		}
		if (obj == this) {
			return true;
		}
		if (obj.getClass() != getClass()) {
			return false;
		}
		JField rhs = (JField) obj;
		return new EqualsBuilder()
			 	.appendSuper(super.equals(obj))
				.append(jClass, rhs.jClass).isEquals();
	}

    @Override
	public int hashCode() {
		return new HashCodeBuilder(11, 47).append(super.hashCode())
				.append(jClass.getName()).toHashCode();
	}
}