AbstractClassAccess.java

package org.jadira.reflection.access;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

import org.jadira.reflection.access.api.ClassAccess;
import org.jadira.reflection.access.api.FieldAccess;
import org.jadira.reflection.access.api.MethodAccess;
import org.jadira.reflection.access.model.ClassModel;
import org.jadira.reflection.core.misc.ClassUtils;

public abstract class AbstractClassAccess<C> implements ClassAccess<C> {

	/**
	 * The class to be accessed
	 */
	private Class<C> clazz;

	/**
	 * An ordered array giving the names of the fields in the class to accessed
	 */
	protected final String[] fieldNames;

	/**
	 * An ordered array giving the Fields in the class to accessed
	 */
	private final Field[] fields;

	private final FieldAccess<C>[] fieldAccess;

	/**
	 * An ordered array giving the names of the methods in the class to accessed
	 */
    private final String[] methodNames;
	
	/**
	 * An ordered array giving the Methods in the class to accessed
	 */
    private final Method[] methods;
    
    private final MethodAccess<C>[] methodAccess;

	private final ClassModel<C> classModel;

	private final ClassAccess<? super C> superClassAccess;

	private final boolean providesHashCode;
	private final boolean providesEquals;
	
	/**
	 * Constructor, intended for use by generated subclasses
	 * @param clazz The Class to be accessed
	 */
	@SuppressWarnings("unchecked")
	protected AbstractClassAccess(Class<C> clazz) {

		this.clazz = clazz;

		Field[] myFields = ClassUtils.collectDeclaredInstanceFields(clazz);

		String[] unsortedFieldNames = new String[myFields.length];
		for (int i = 0; i < unsortedFieldNames.length; i++) {
			unsortedFieldNames[i] = myFields[i].getName();
		}
		fieldNames = Arrays.copyOf(unsortedFieldNames, unsortedFieldNames.length);
		Arrays.sort(fieldNames);

		final FieldAccess<C>[] myFieldAccess = (FieldAccess<C>[]) new FieldAccess[myFields.length];
		fields = new Field[myFields.length];

		for (int i = 0; i < fields.length; i++) {

			String fieldName = unsortedFieldNames[i];
			for (int tIdx = 0; tIdx < unsortedFieldNames.length; tIdx++) {
				if (fieldName.equals(fieldNames[tIdx])) {
					myFieldAccess[tIdx] = constructFieldAccess(myFields[i]);
					fields[tIdx] = myFields[i];
					break;
				}
			}

		}
		fieldAccess = myFieldAccess;
		
        Method[] myMethods = ClassUtils.collectDeclaredMethods(clazz);
        
        String[] unsortedMethodNames = new String[myMethods.length];
        for (int i=0; i < unsortedMethodNames.length; i++) {
            unsortedMethodNames[i] = myMethods[i].getName();
        }
        methodNames = Arrays.copyOf(unsortedMethodNames, unsortedMethodNames.length);
        Arrays.sort(methodNames);
        
        final MethodAccess<C>[] myMethodAccess = (MethodAccess<C>[])new MethodAccess[myMethods.length];
        methods = new Method[myMethods.length];
        
        for (int i=0; i < methods.length; i++) {
   
            String methodName = unsortedMethodNames[i];
            for (int tIdx = 0; tIdx < unsortedMethodNames.length; tIdx++) {
                if (methodName.equals(methodNames[tIdx])) {
                    myMethodAccess[tIdx] = constructMethodAccess(myMethods[i]);
                    methods[tIdx] = myMethods[i];
                    break;
                }
            }
        }
        methodAccess = myMethodAccess;
		
		final Class<?> superClass = clazz.getSuperclass();
		if (superClass != null) {
			this.superClassAccess = constructClassAccess(clazz.getSuperclass());
		} else {
			this.superClassAccess = null;
		}
        
		this.classModel = ClassModel.get(this);
			
		Class<?> hashcodeClass;
		try {
			hashcodeClass = clazz.getMethod("hashCode").getDeclaringClass();
		} catch (NoSuchMethodException e) {
			throw new IllegalStateException("hashCode() method could not be found: " + e.getMessage(), e);
		} catch (SecurityException e) {
			throw new IllegalStateException("hashCode() method could not be accessed: " + e.getMessage(), e);
		}
		
		providesHashCode = hashcodeClass.equals(clazz);
		
		Class<?> equalsClass;
		try {
			equalsClass = clazz.getMethod("equals", Object.class).getDeclaringClass();
		} catch (NoSuchMethodException e) {
			throw new IllegalStateException("equals() method could not be found: " + e.getMessage(), e);
		} catch (SecurityException e) {
			throw new IllegalStateException("equals() method could not be accessed: " + e.getMessage(), e);
		}
		
		providesEquals = equalsClass.equals(clazz);
	}
	
	@Override
	public Class<C> getType() {
		return clazz;
	}

	@Override
	public FieldAccess<C>[] getDeclaredFieldAccessors() {
		return fieldAccess;
	}

	@Override
	public FieldAccess<C> getDeclaredFieldAccess(Field f) {
		int idx = Arrays.binarySearch(fieldNames, f.getName());
		return fieldAccess[idx];
	}
	

    @Override
    public MethodAccess<C>[] getDeclaredMethodAccessors() {
        return methodAccess;
    }
    
	@Override
	public MethodAccess<C> getDeclaredMethodAccess(Method m) {
		int idx = Arrays.binarySearch(methodNames, m.getName());
		if (methodAccess[idx].method().equals(m)) {
			return methodAccess[idx];
		}
		int backTrack = idx;
		while (true) {
			if (methodAccess[backTrack].method().equals(m)) {
				return methodAccess[idx];
			}
			if (!(methodAccess[backTrack].method().getName()
					.equals(m.getName()))) {
				break;
			}
			backTrack = backTrack - 1;
		}
		while (true) {
			idx = idx + 1;
			if (methodAccess[idx].method().equals(m)) {
				return methodAccess[idx];
			}
			if (!(methodAccess[idx].method().getName().equals(m.getName()))) {
				break;
			}
		}
		return null;
	}
	
	@Override
	public ClassModel<C> getClassModel() {
		return classModel;
	}

	protected String[] getDeclaredFieldNames() {
		return fieldNames;
	}
	
	protected Field[] getDeclaredFields() {
		return fields;
	}

	protected String[] getDeclaredMethodNames() {
		return methodNames;
	}
	
	protected Method[] getDeclaredMethods() {
		return methods;
	}
	
	@Override
	public ClassAccess<? super C> getSuperClassAccess() {
		return superClassAccess;
	}
	

	@Override
	public boolean providesHashCode() {
		return providesHashCode;
	}
	
	@Override
	public boolean providesEquals() {
		return providesEquals;
	}
	
	protected abstract FieldAccess<C> constructFieldAccess(Field field);
	
	protected abstract MethodAccess<C> constructMethodAccess(Method method);
	
	protected abstract <X> ClassAccess<X> constructClassAccess(Class<X> clazz);
}