AbstractPropertyProcessor

/*
 * Copyright 2012 Olivier Godineau
 *
 * 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 olg.csv.bean.impl;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import olg.csv.base.Row;
import olg.csv.bean.IBeanProcessor;
import olg.csv.bean.IPropertyProcessor;
import olg.csv.bean.getter.AbstractGetter;
import olg.csv.bean.parser.AbstractParser;
import olg.csv.bean.parser.ParseException;

/**
 * In reading process, Class responsible of bean properties instantiation from
 * list of Strings. This class seems to be the same as {@link BeanProcessor}
 * class. But its motivation is different : We want to instantiate a
 * characteristic of a bean while Transformer allows to product bean completed
 * with its properties set by PropertyTransformers
 *
 * @author Olivier Godineau
 *
 * @param <B>
 *            dedicated bean the Propertytransformer deals with
 *
 */
public abstract class AbstractPropertyProcessor<B> implements IPropertyProcessor<B> {

	/**
	 * The class of the bean this transformer deals with.
	 */
	protected Class<B> beanClass = null;

	/**
	 * the method used to set the property of a &lt;B&gt; bean.
	 */
	protected Method method = null;

	/**
	 * Returns the class of the bean this transformer deals with.
	 *
	 * @return the bean class.
	 */
	public final Class<B> getBeanClass() {
		return beanClass;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see olg.csv.bean.impl.IPropertyProcessor#transform(olg.csv.base.Row, B)
	 */
	public abstract B transform(Row line, B bean);

	/**
	 * allows to set field of a bean.
	 *
	 * @param field
	 *            the value of the field
	 * @param bean
	 *            the bean to set its field
	 * @return the bean, if B argument is <code>null</code> return a new bean
	 *         with its field setted.
	 */
	protected final B invoke(Object field, B bean) {
		B retour = bean;

		try { // On remplit le champ du bean
			if (retour == null) {
				retour = beanClass.newInstance();
			}

			method.invoke(retour, new Object[]{field});

		} catch (IllegalArgumentException e) {
			throw new ParseException("Error on method invocation  " + method.getName(), e);
		} catch (IllegalAccessException e) {
			throw new ParseException("Error on method invocation  " + method.getName(), e);
		} catch (InvocationTargetException e) {
			throw new ParseException("Error on method invocation  " + method.getName(), e);
		} catch (InstantiationException e) {
			throw new ParseException("Error on method invocation  " + method.getName(), e);

		}

		return retour;
	}

	/**
	 * Returns a simple property processor which set a property of bean with the
	 * help of a getter and a parser. Typically the case when a property matches
	 * a string from a list of Strings.
	 *
	 * @param getter
	 *            the getter. Allows to extract a sting corresponding to the
	 *            property to set. Must be not <code>null</code>.
	 * @param parser
	 *            the parser. Allows to instantiate the property from a String.
	 *            Must be not <code>null</code>.
	 * @param propertyName
	 *            the name of the property to set. Must be not <code>null</code>
	 *            .
	 * @param clazz
	 *            the bean class. Must be not <code>null</code>.
	 * @param <T>
	 *            the bean type
	 * @param <X>
	 *            the property type
	 * @return new instance of an basic property processor.
	 *
	 * @see #transform(Row, Object)
	 */

	public static final <T, X> IPropertyProcessor<T> getSimplePropertyTransformer(AbstractGetter getter,
			AbstractParser<X> parser, String propertyName, Class<T> clazz) {
		if (parser == null) {
			throw new IllegalArgumentException("getSimplePropertyTransformer: "
					+ "AbstractParser argument must be not null");
		}
		if (propertyName == null) {
			throw new IllegalArgumentException("getSimplePropertyTransformer: propertyName argument must be not null");
		}
		if (clazz == null) {
			throw new IllegalArgumentException("getSimplePropertyTransformer: Class argument must be not null");
		}

		if (getter == null) {
			throw new IllegalArgumentException("getSimplePropertyTransformer: "
					+ "AbstractGetter argument must be not null");
		}
		return new PropertyProcessor<T>(getter, parser, propertyName, clazz);
	}

	/**
	 * Returns a property processor which set a property of a bean with the help
	 * of a transformer. Typically the case where we instanciate a bean from a
	 * list of Strings we want to set as a property of our final bean
	 *
	 * @param transformer
	 *            the transformer which products the value of the property to
	 *            set. Must not be <code>null</code>.
	 * @param beanClass
	 *            the class of the bean to return. Must not be <code>null</code>
	 *            .
	 * @param propertyName
	 *            the name of the property to set. Must not be <code>null</code>
	 *            .
	 * @param <T>
	 *            the bean type
	 * @param <P>
	 *            th property type
	 * @return new instance
	 */
	public static final <T, P> IPropertyProcessor<T> getComplexPropertyTransformer(IBeanProcessor<P> transformer,
			Class<T> beanClass, String propertyName) {
		if (transformer == null) {
			throw new IllegalArgumentException("Transformer argument must be not null");
		}
		if (beanClass == null) {
			throw new IllegalArgumentException("Class argument must be not null");
		}
		if (propertyName == null) {
			throw new IllegalArgumentException("propertyName argument must be not null");
		}
		return new ComplexPropertyProcessor<T>(transformer, beanClass, propertyName);
	}

}