org.simpleflatmapper.jooq.RecordUnmapperBuilder Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of sfm-jooq Show documentation
jOOQ supports.
There is a newer version: 9.0.2
package org.simpleflatmapper.jooq;


import org.jooq.Configuration;
import org.jooq.Field;
import org.jooq.Record;
import org.jooq.impl.DSL;
import org.simpleflatmapper.converter.*;
import org.simpleflatmapper.map.*;
import org.simpleflatmapper.map.mapper.AbstractConstantTargetMapperBuilder;
import org.simpleflatmapper.map.mapper.ConstantTargetFieldMapperFactoryImpl;
import org.simpleflatmapper.map.mapper.PropertyMapping;
import org.simpleflatmapper.map.property.ConverterProperty;
import org.simpleflatmapper.map.property.FieldMapperColumnDefinition;
import org.simpleflatmapper.map.setter.ContextualSetter;
import org.simpleflatmapper.map.setter.ContextualSetterFactory;
import org.simpleflatmapper.reflect.*;
import org.simpleflatmapper.reflect.meta.*;
import org.simpleflatmapper.util.TypeHelper;

import java.lang.reflect.Type;

public class RecordUnmapperBuilder extends AbstractConstantTargetMapperBuilder> {


    private static final ContextualSetterFactory> SETTER_FACTORY = new ContextualSetterFactory>() {

        @Override
        public  ContextualSetter getSetter(PropertyMapping pm, ContextFactoryBuilder contextFactoryBuilder) {
            Type propertyType = pm.getPropertyMeta().getPropertyType();
            final Field field = pm.getColumnKey().getField();
            Class fieldType = field.getType();

            if (TypeHelper.isAssignable(fieldType, propertyType)) {
                return new RecordContextualSetter
((Field) field);
            } else {
                ContextualConverter converter;
                if (pm.getColumnDefinition().has(ConverterProperty.class)) {
                    ConverterProperty converterProperty = pm.getColumnDefinition().lookFor(ConverterProperty.class);
                    converter = converterProperty.function;
                } else {
                    converter = ConverterService.getInstance().findConverter(propertyType, fieldType, contextFactoryBuilder, pm.getColumnDefinition().properties());
                }

                if (converter != null) {
                    return new RecordWithConverterContextualSetter(field, converter);
                }

            }
            return null;
        }
    };

    private Field[] fields;
    private final Configuration configuration;

    public RecordUnmapperBuilder(
            ClassMeta classMeta,
            MapperConfig mapperConfig,
            Configuration configuration) {
        super(classMeta, Record.class, mapperConfig, ConstantTargetFieldMapperFactoryImpl.newInstance(SETTER_FACTORY, Record.class));
        this.configuration = configuration;
    }

    @Override
    protected BiInstantiator, Record> getInstantiator() {
        final Field[] fields = this.fields;
        final Configuration conf = this.configuration;
        return new BiInstantiator, Record>() {
            @Override
            public Record newInstance(E e, MappingContext mappingContext) {
                return DSL.using(conf).newRecord(fields);
            }
        };
    }

    @Override
    protected JooqFieldKey newKey(String column, int i, FieldMapperColumnDefinition columnDefinition) {
        throw new UnsupportedOperationException();
    }


    protected int getStartingIndex() {
        return Integer.MIN_VALUE;
    }


    public void setFields(Field[] fields) {
        this.fields = fields;
        int i = 0;
        for(Field f : fields) {
            addColumn(new JooqFieldKey(f, i++));
        }
    }
    private static class RecordContextualSetter implements ContextualSetter {
        private final Field field;

        public RecordContextualSetter(Field field) {
            this.field = field;
        }

        @Override
        public void set(Record target, P value, Context context) {
            target.set(field, value);
        }
    }

    private static class RecordWithConverterContextualSetter implements ContextualSetter {
        private final ContextualConverter converter;
        private final Field field;

        public RecordWithConverterContextualSetter(Field field, ContextualConverter converter) {
            this.field = field;
            this.converter = converter;
        }

        @Override
        public void set(Record target, P value, Context context) throws Exception {
            target.set(field, converter.convert(value, context));
        }
    }
}