org.simpleflatmapper.map.mapper.ConstantTargetFieldMapperFactoryImpl Maven / Gradle / Ivy

Go to download
package org.simpleflatmapper.map.mapper;


import org.simpleflatmapper.map.FieldKey;
import org.simpleflatmapper.map.FieldMapper;
import org.simpleflatmapper.map.MapperBuilderErrorHandler;
import org.simpleflatmapper.map.property.FieldMapperColumnDefinition;
import org.simpleflatmapper.map.context.MappingContextFactoryBuilder;
import org.simpleflatmapper.reflect.Getter;
import org.simpleflatmapper.reflect.Setter;
import org.simpleflatmapper.reflect.SetterFactory;
import org.simpleflatmapper.reflect.setter.SetterOnGetter;
import org.simpleflatmapper.reflect.meta.ClassMeta;
import org.simpleflatmapper.reflect.meta.ObjectClassMeta;
import org.simpleflatmapper.reflect.meta.PropertyMeta;
import org.simpleflatmapper.reflect.primitive.BooleanGetter;
import org.simpleflatmapper.reflect.primitive.BooleanSetter;
import org.simpleflatmapper.reflect.primitive.ByteGetter;
import org.simpleflatmapper.reflect.primitive.ByteSetter;
import org.simpleflatmapper.reflect.primitive.CharacterGetter;
import org.simpleflatmapper.reflect.primitive.CharacterSetter;
import org.simpleflatmapper.reflect.primitive.DoubleGetter;
import org.simpleflatmapper.reflect.primitive.DoubleSetter;
import org.simpleflatmapper.reflect.primitive.FloatGetter;
import org.simpleflatmapper.reflect.primitive.FloatSetter;
import org.simpleflatmapper.reflect.primitive.IntGetter;
import org.simpleflatmapper.reflect.primitive.IntSetter;
import org.simpleflatmapper.reflect.primitive.LongGetter;
import org.simpleflatmapper.reflect.primitive.LongSetter;
import org.simpleflatmapper.reflect.primitive.ShortGetter;
import org.simpleflatmapper.reflect.primitive.ShortSetter;
import org.simpleflatmapper.map.fieldmapper.BooleanFieldMapper;
import org.simpleflatmapper.map.fieldmapper.ByteFieldMapper;
import org.simpleflatmapper.map.fieldmapper.CharacterFieldMapper;
import org.simpleflatmapper.map.fieldmapper.DoubleFieldMapper;
import org.simpleflatmapper.map.fieldmapper.FieldMapperImpl;
import org.simpleflatmapper.map.fieldmapper.FloatFieldMapper;
import org.simpleflatmapper.map.fieldmapper.IntFieldMapper;
import org.simpleflatmapper.map.fieldmapper.LongFieldMapper;
import org.simpleflatmapper.map.fieldmapper.ShortFieldMapper;
import org.simpleflatmapper.util.ErrorDoc;
import org.simpleflatmapper.util.TypeHelper;

import java.lang.reflect.Type;

public class ConstantTargetFieldMapperFactoryImpl> implements ConstantTargetFieldMapperFactory {

    private final SetterFactory>> setterFactory;
    private final Type targetType;

    private ConstantTargetFieldMapperFactoryImpl(SetterFactory>> setterFactory, Type targetType) {
        this.setterFactory = setterFactory;
        this.targetType = targetType;
    }

    @SuppressWarnings("unchecked")
    @Override
    public  FieldMapper newFieldMapper(
            PropertyMapping> pm,
            MappingContextFactoryBuilder contextFactoryBuilder,
            MapperBuilderErrorHandler mappingErrorHandler) {

        Getter getter =
                (Getter) pm.getColumnDefinition().getCustomGetterFrom(pm.getPropertyMeta().getOwnerType());

        if (getter == null) {
            getter = pm.getPropertyMeta().getGetter();
        }

        if (getter == null) {
            mappingErrorHandler.accessorNotFound("Could not find getter for " + pm.getColumnKey() + " type "
                    + pm.getPropertyMeta().getPropertyType()
                    + " path " + pm.getPropertyMeta().getPath() + ", See " + ErrorDoc.toUrl("CTFM_GETTER_NOT_FOUND"));
            return null;
        }

        Setter setter = getSetterForTarget(pm);


        if (setter == null) {
            mappingErrorHandler.accessorNotFound("Could not find setter for " + pm.getColumnKey() + " type "
                    + pm.getPropertyMeta().getPropertyType()
                    + " path " + pm.getPropertyMeta().getPath() 
                    + " See " + ErrorDoc.toUrl("CTFM_SETTER_NOT_FOUND"));
            return null;
        }

        Type propertyType = pm.getPropertyMeta().getPropertyType();

        return buildFieldMapper(getter, setter, propertyType);
    }

    @SuppressWarnings("unchecked")
    private  FieldMapper buildFieldMapper(Getter getter, Setter setter, Type propertyType) {
        if (TypeHelper.isPrimitive(propertyType)) {
            if (getter instanceof BooleanGetter && setter instanceof BooleanSetter) {
                return new BooleanFieldMapper((BooleanGetter)getter, (BooleanSetter) setter);
            } else if (getter instanceof ByteGetter && setter instanceof ByteSetter) {
                return new ByteFieldMapper((ByteGetter)getter, (ByteSetter) setter);
            } else if (getter instanceof CharacterGetter && setter instanceof CharacterSetter) {
                return new CharacterFieldMapper((CharacterGetter)getter, (CharacterSetter) setter);
            } else if (getter instanceof ShortGetter && setter instanceof ShortSetter) {
                return new ShortFieldMapper((ShortGetter)getter, (ShortSetter) setter);
            } else if (getter instanceof IntGetter && setter instanceof IntSetter) {
                return new IntFieldMapper((IntGetter)getter, (IntSetter) setter);
            } else if (getter instanceof LongGetter && setter instanceof LongSetter) {
                return new LongFieldMapper((LongGetter)getter, (LongSetter) setter);
            } else if (getter instanceof FloatGetter && setter instanceof FloatSetter) {
                return new FloatFieldMapper((FloatGetter)getter, (FloatSetter) setter);
            } else if (getter instanceof DoubleGetter && setter instanceof DoubleSetter) {
                return new DoubleFieldMapper((DoubleGetter)getter, (DoubleSetter) setter);
            }
        }

        return new FieldMapperImpl(getter, setter);
    }

    @SuppressWarnings("unchecked")
    private  Setter getSetterForTarget(PropertyMapping> pm) {
        Setter setter = (Setter) pm.getColumnDefinition().getCustomSetterTo(targetType);

        final SetterFactory>> customSetterFactory =
                (SetterFactory>>) pm.getColumnDefinition().getCustomSetterFactoryTo(targetType);

        if (customSetterFactory != null) {
            setter = customSetterFactory.getSetter(pm);
        }

        if (setter == null){
            setter = setterFactory.getSetter(pm);
        }

        if (setter == null) {
            if (!pm.getPropertyMeta().isSelf()) {
                final ClassMeta propertyClassMeta = pm.getPropertyMeta().getPropertyClassMeta();
                if (propertyClassMeta instanceof ObjectClassMeta) {
                    ObjectClassMeta ocm = (ObjectClassMeta) propertyClassMeta;

                    if (ocm.getNumberOfProperties() == 1) {
                        PropertyMeta subProp = ocm.getFirstProperty();

                        Setter subSetter = getSetterForTarget(pm.propertyMeta(subProp));

                        if (subSetter != null) {
                            return new SetterOnGetter(subSetter, (Getter) subProp.getGetter());
                        }
                    }
                }
            }
        }
        return setter;
    }

    public static > ConstantTargetFieldMapperFactory newInstance(
            SetterFactory>> setterFactory, Type targetType) {
        return new ConstantTargetFieldMapperFactoryImpl(setterFactory, targetType);
    }



}