org.sfm.reflect.SetterFactory Maven / Gradle / Ivy

Go to download
package org.sfm.reflect;

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

import org.sfm.reflect.asm.AsmFactory;
import org.sfm.reflect.primitive.BooleanFieldSetter;
import org.sfm.reflect.primitive.BooleanMethodSetter;
import org.sfm.reflect.primitive.BooleanSetter;
import org.sfm.reflect.primitive.ByteFieldSetter;
import org.sfm.reflect.primitive.ByteMethodSetter;
import org.sfm.reflect.primitive.ByteSetter;
import org.sfm.reflect.primitive.CharacterFieldSetter;
import org.sfm.reflect.primitive.CharacterMethodSetter;
import org.sfm.reflect.primitive.CharacterSetter;
import org.sfm.reflect.primitive.DoubleFieldSetter;
import org.sfm.reflect.primitive.DoubleMethodSetter;
import org.sfm.reflect.primitive.DoubleSetter;
import org.sfm.reflect.primitive.FloatFieldSetter;
import org.sfm.reflect.primitive.FloatMethodSetter;
import org.sfm.reflect.primitive.FloatSetter;
import org.sfm.reflect.primitive.IntFieldSetter;
import org.sfm.reflect.primitive.IntMethodSetter;
import org.sfm.reflect.primitive.IntSetter;
import org.sfm.reflect.primitive.LongFieldSetter;
import org.sfm.reflect.primitive.LongMethodSetter;
import org.sfm.reflect.primitive.LongSetter;
import org.sfm.reflect.primitive.ShortFieldSetter;
import org.sfm.reflect.primitive.ShortMethodSetter;
import org.sfm.reflect.primitive.ShortSetter;

public final class SetterFactory {
	
	private final AsmFactory asmFactory;
	
	public SetterFactory(final AsmFactory asmFactory) {
		this.asmFactory = asmFactory;
	}
	
	public AsmFactory getAsmFactory() {
		return asmFactory;
	}

	public  Setter getSetter(final Class target, final String property) {
		// first look for method
		final Method method = lookForMethod(target, property);
		
		if (method == null) {
			return getFieldSetter(target, property);
		} else {
			return getMethodSetter(method);
		}
	}

	public  Setter getMethodSetter(final Method method) {
		if (asmFactory != null) {
			try {
				return asmFactory.createSetter(method);
			} catch(Exception e) {
				return new MethodSetter(method);
			}
		} else {
			return new MethodSetter(method);
		}
	}

	public  FieldSetter getFieldSetter(final Class target, final String property) {
		// look for field
		final Field field = lookForField(target, property);
		
		if (field != null) {
			field.setAccessible(true);
			return new FieldSetter(field);
		} else {
			return null;
		}
	}

	private Method lookForMethod(final Class target, final String property) {
		
		for(Method m : target.getDeclaredMethods()) {
			if(SetterHelper.methodModifiersMatches(m.getModifiers())
					&& SetterHelper.methodNameMatchesProperty(m.getName(), property)) {
				return m;
			}
		}
		
		if (!Object.class.equals(target)) {
			return lookForMethod(target.getSuperclass(), property);
		}
		
		return null;
	}
	

	private Field lookForField(final Class target, final String property) {
		for(Field field : target.getDeclaredFields()) {
			if(SetterHelper.fieldModifiersMatches(field.getModifiers())
					&& SetterHelper.fieldNameMatchesProperty(field.getName(), property)) {
				return field;
			}
		}
		
		if (!Object.class.equals(target)) {
			return lookForField(target.getSuperclass(), property);
		}
		
		return null;
	}
	

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  BooleanSetter toBooleanSetter(final Setter setter) {
		if (setter instanceof BooleanSetter) {
			return (BooleanSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new BooleanMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new BooleanFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  ByteSetter toByteSetter(final Setter setter) {
		if (setter instanceof ByteSetter) {
			return (ByteSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new ByteMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new ByteFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  CharacterSetter toCharacterSetter(final Setter setter) {
		if (setter instanceof CharacterSetter) {
			return (CharacterSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new CharacterMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new CharacterFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  ShortSetter toShortSetter(final Setter setter) {
		if (setter instanceof ShortSetter) {
			return (ShortSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new ShortMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new ShortFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  IntSetter toIntSetter(final Setter setter) {
		if (setter instanceof IntSetter) {
			return (IntSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new IntMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new IntFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  LongSetter toLongSetter(final Setter setter) {
		if (setter instanceof LongSetter) {
			return (LongSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new LongMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new LongFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  FloatSetter toFloatSetter(final Setter setter) {
		if (setter instanceof FloatSetter) {
			return (FloatSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new FloatMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new FloatFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public  DoubleSetter toDoubleSetter(final Setter setter) {
		if (setter instanceof DoubleSetter) {
			return (DoubleSetter) setter;
		} else if (setter instanceof MethodSetter) {
			return new DoubleMethodSetter(((MethodSetter) setter).getMethod());
		} else if (setter instanceof FieldSetter) {
			return new DoubleFieldSetter(((FieldSetter) setter).getField());
		} else {
			throw new IllegalArgumentException("Invalid type " + setter);
		}
	}

}