Examples with Getter org.simpleflatmapper.reflect.Getter used on opensource projects

Example 6 with Getter

use of org.simpleflatmapper.reflect.Getter in project SimpleFlatMapper by arnaudroger.

the class RowGetterFactory method newGetter.

@SuppressWarnings("unchecked")
@Override
public <P> Getter<GettableByIndexData, P> newGetter(Type target, DatastaxColumnKey key, Object... properties) {
    Class<?> targetClass = TypeHelper.toClass(target);
    if (Date.class.equals(targetClass)) {
        return (Getter<GettableByIndexData, P>) new DatastaxTimestampGetter(key.getIndex());
    }
    if (boolean.class.equals(targetClass) || Boolean.class.equals(targetClass)) {
        return (Getter<GettableByIndexData, P>) new DatastaxBooleanGetter(key.getIndex());
    }
    if (InetAddress.class.equals(targetClass)) {
        return (Getter<GettableByIndexData, P>) new DatastaxInetAddressGetter(key.getIndex());
    }
    if (TupleValue.class.equals(targetClass)) {
        return (Getter<GettableByIndexData, P>) new DatastaxTupleValueGetter(key.getIndex());
    }
    if (Collection.class.isAssignableFrom(targetClass)) {
        Type elementType = TypeHelper.getComponentTypeOfListOrArray(target);
        Class<?> dataTypeClass = Object.class;
        Class<?> dataTypeElt = null;
        DataType dtElt = null;
        if (key.getDataType() != null) {
            DataType dataType = key.getDataType();
            dataTypeClass = DataTypeHelper.asJavaClass(dataType);
            if (dataType.isCollection()) {
                dtElt = key.getDataType().getTypeArguments().get(0);
                dataTypeElt = DataTypeHelper.asJavaClass(dtElt);
            }
        } else {
            dataTypeElt = TypeHelper.toClass(elementType);
        }
        if (dataTypeElt != null) {
            if (TypeHelper.areEquals(elementType, dataTypeElt)) {
                if (Set.class.equals(dataTypeClass)) {
                    if (targetClass.isAssignableFrom(dataTypeClass)) {
                        return new DatastaxSetGetter(key.getIndex(), TypeHelper.toClass(elementType));
                    }
                }
                if (List.class.equals(dataTypeClass)) {
                    if (targetClass.isAssignableFrom(dataTypeClass)) {
                        return new DatastaxListGetter(key.getIndex(), TypeHelper.toClass(elementType));
                    }
                }
            } else {
                Converter<?, ?> converter = getConverter(elementType, dataTypeElt, dtElt);
                if (converter != null) {
                    if (Set.class.equals(dataTypeClass)) {
                        if (targetClass.isAssignableFrom(dataTypeClass)) {
                            return new DatastaxSetWithConverterGetter(key.getIndex(), dataTypeElt, converter);
                        }
                    }
                    if (List.class.equals(dataTypeClass)) {
                        if (targetClass.isAssignableFrom(dataTypeClass)) {
                            return new DatastaxListWithConverterGetter(key.getIndex(), dataTypeElt, converter);
                        }
                    }
                }
            }
        }
    }
    if (Map.class.equals(targetClass)) {
        TypeHelper.MapEntryTypes keyValueTypeOfMap = TypeHelper.getKeyValueTypeOfMap(target);
        Class<?> dtKeyType = null;
        Class<?> dtValueType = null;
        DataType dtKey = null;
        DataType dtValue = null;
        if (key.getDataType() != null) {
            List<DataType> typeArguments = key.getDataType().getTypeArguments();
            if (typeArguments.size() == 2) {
                dtKey = typeArguments.get(0);
                dtKeyType = DataTypeHelper.asJavaClass(dtKey);
                dtValue = typeArguments.get(1);
                dtValueType = DataTypeHelper.asJavaClass(dtValue);
            }
        } else {
            dtKeyType = TypeHelper.toClass(keyValueTypeOfMap.getKeyType());
            dtValueType = TypeHelper.toClass(keyValueTypeOfMap.getValueType());
        }
        if (dtKeyType != null && dtValueType != null) {
            if (TypeHelper.areEquals(keyValueTypeOfMap.getKeyType(), dtKeyType) && TypeHelper.areEquals(keyValueTypeOfMap.getValueType(), dtValueType)) {
                return new DatastaxMapGetter(key.getIndex(), TypeHelper.toClass(keyValueTypeOfMap.getKeyType()), TypeHelper.toClass(keyValueTypeOfMap.getValueType()));
            } else {
                Converter<?, ?> keyConverter = getConverter(keyValueTypeOfMap.getKeyType(), dtKeyType, dtKey);
                Converter<?, ?> valueConverter = getConverter(keyValueTypeOfMap.getValueType(), dtValueType, dtValue);
                if (keyConverter != null && valueConverter != null) {
                    return new DatastaxMapWithConverterGetter(key.getIndex(), dtKeyType, dtValueType, keyConverter, valueConverter);
                }
            }
        }
    }
    if (TupleHelper.isTuple(target)) {
        if (key.getDataType() != null && key.getDataType() instanceof TupleType) {
            TupleType tt = (TupleType) key.getDataType();
            List<DataType> typeArguments = tt.getTypeArguments();
            TypeVariable<? extends Class<?>>[] typeParameters = targetClass.getTypeParameters();
            if (typeArguments.size() <= typeParameters.length) {
                return (Getter<GettableByIndexData, P>) DatastaxTupleGetter.newInstance(datastaxMapperFactory, target, tt, key.getIndex());
            }
        }
    }
    if (TypeHelper.isEnum(target)) {
        final Getter<GettableByIndexData, ? extends Enum> getter = enumGetter(key, TypeHelper.toClass(target));
        if (getter != null) {
            return (Getter<GettableByIndexData, P>) getter;
        }
    }
    if (key.getDataType() != null && key.getDataType() instanceof UserType) {
        UserType ut = (UserType) key.getDataType();
        return (Getter<GettableByIndexData, P>) DatastaxUDTGetter.newInstance(datastaxMapperFactory, target, ut, key.getIndex());
    }
    Getter<GettableByIndexData, P> getter = getterFromFactories(target, key, properties);
    if (getter != null)
        return getter;
    return null;
}

Example 7 with Getter

use of org.simpleflatmapper.reflect.Getter in project SimpleFlatMapper by arnaudroger.

the class AsmFactoryTest method testCreateInstantiatorFinalDbObjectInjectIdAndName.

@Test
public void testCreateInstantiatorFinalDbObjectInjectIdAndName() throws Exception {
    ExecutableInstantiatorDefinition instantiatorDefinition = (ExecutableInstantiatorDefinition) AsmInstantiatorDefinitionFactory.extractDefinitions(DbFinalObject.class).get(0);
    HashMap<Parameter, Getter<? super Object, ?>> injections = new HashMap<Parameter, Getter<? super Object, ?>>();
    injections.put(new Parameter(0, "id", long.class), new ConstantLongGetter<Object>(33l));
    injections.put(new Parameter(1, "name", String.class), new ConstantGetter<Object, String>("fdo"));
    Instantiator<Object, DbFinalObject> instantiator = asmFactory.createInstantiator(Object.class, instantiatorDefinition, injections, true);
    DbFinalObject fdo = instantiator.newInstance(new Object());
    assertNotNull(fdo);
    assertNull(fdo.getEmail());
    assertNull(fdo.getCreationTime());
    assertNull(fdo.getTypeName());
    assertNull(fdo.getTypeOrdinal());
    assertEquals(33l, fdo.getId());
    assertEquals("fdo", fdo.getName());
    assertSame(instantiator.getClass(), asmFactory.createInstantiator(Object.class, instantiatorDefinition, injections, true).getClass());
}

Example 8 with Getter

use of org.simpleflatmapper.reflect.Getter in project SimpleFlatMapper by arnaudroger.

the class AsmFactoryTest method testCreateInstantiatorFinalDbObjectNameAndType.

@Test
public void testCreateInstantiatorFinalDbObjectNameAndType() throws Exception {
    HashMap<Parameter, Getter<? super Object, ?>> injections = new HashMap<Parameter, Getter<? super Object, ?>>();
    ConstantIntGetter<Object> getter = new ConstantIntGetter<Object>(1);
    injections.put(new Parameter(4, "typeOrdinal", Type.class), new OrdinalEnumGetter<Object, Type>(getter, Type.class));
    injections.put(new Parameter(1, "name", String.class), new ConstantGetter<Object, String>("fdo"));
    List<InstantiatorDefinition> instantiatorDefinitions = AsmInstantiatorDefinitionFactory.extractDefinitions(DbFinalObject.class);
    Instantiator<Object, DbFinalObject> instantiator = asmFactory.createInstantiator(Object.class, (ExecutableInstantiatorDefinition) instantiatorDefinitions.get(0), injections, true);
    DbFinalObject fdo = instantiator.newInstance(new Object());
    assertNotNull(fdo);
    assertNull(fdo.getEmail());
    assertNull(fdo.getCreationTime());
    assertNull(fdo.getTypeName());
    assertEquals(0, fdo.getId());
    assertEquals("fdo", fdo.getName());
    assertEquals(Type.type2, fdo.getTypeOrdinal());
}

Example 9 with Getter

use of org.simpleflatmapper.reflect.Getter in project SimpleFlatMapper by arnaudroger.

the class CellSetterFactory method newDelayedGetter.

@SuppressWarnings("unchecked")
public <T, P> Getter<CsvMapperCellHandler<T>, P> newDelayedGetter(CsvColumnKey key, Type type) {
    Class<?> clazz = TypeHelper.toClass(type);
    Getter getter;
    int columnIndex = key.getIndex();
    if (clazz.isPrimitive()) {
        if (boolean.class.equals(clazz)) {
            getter = new BooleanDelayedGetter<T>(columnIndex);
        } else if (byte.class.equals(clazz)) {
            getter = new ByteDelayedGetter<T>(columnIndex);
        } else if (char.class.equals(clazz)) {
            getter = new CharDelayedGetter<T>(columnIndex);
        } else if (short.class.equals(clazz)) {
            getter = new ShortDelayedGetter<T>(columnIndex);
        } else if (int.class.equals(clazz)) {
            getter = new IntDelayedGetter<T>(columnIndex);
        } else if (long.class.equals(clazz)) {
            getter = new LongDelayedGetter<T>(columnIndex);
        } else if (float.class.equals(clazz)) {
            getter = new FloatDelayedGetter<T>(columnIndex);
        } else if (double.class.equals(clazz)) {
            getter = new DoubleDelayedGetter<T>(columnIndex);
        } else {
            throw new IllegalArgumentException("Unexpected primitive " + clazz);
        }
    } else {
        getter = new DelayedGetter<T, P>(columnIndex);
    }
    return getter;
}

Example 10 with Getter

use of org.simpleflatmapper.reflect.Getter in project SimpleFlatMapper by arnaudroger.

the class PreparedStatementMapperBuilder method buildIndexFieldMappers.

@SuppressWarnings("unchecked")
public MultiIndexFieldMapper<T>[] buildIndexFieldMappers() {
    final List<MultiIndexFieldMapper<T>> fields = new ArrayList<MultiIndexFieldMapper<T>>();
    propertyMappingsBuilder.forEachProperties(new ForEachCallBack<PropertyMapping<T, ?, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>>>() {

        @Override
        public void handle(PropertyMapping<T, ?, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>> pm) {
            if (isMultiIndex(pm.getPropertyMeta())) {
                fields.add(newCollectionFieldMapper(pm));
            } else {
                fields.add(newFieldMapper(pm));
            }
        }

        private <P, C> MultiIndexFieldMapper<T> newCollectionFieldMapper(PropertyMapping<T, P, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>> pm) {
            PropertyMeta<T, ?> propertyMeta = pm.getPropertyMeta();
            IndexedGetter<C, P> indexedGetter;
            IntGetter<? super C> sizeGetter;
            Getter<T, C> collectionGetter = (Getter<T, C>) propertyMeta.getGetter();
            if (TypeHelper.isAssignable(List.class, propertyMeta.getPropertyType())) {
                indexedGetter = (IndexedGetter<C, P>) new ListIndexedGetter<P>();
                sizeGetter = (IntGetter<C>) new ListSizeGetter();
            } else if (TypeHelper.isArray(propertyMeta.getPropertyType())) {
                indexedGetter = (IndexedGetter<C, P>) new ArrayIndexedGetter<P>();
                sizeGetter = new ArraySizeGetter();
            } else {
                throw new IllegalArgumentException("Unexpected elementMeta" + propertyMeta);
            }
            PropertyMeta<C, P> childProperty = (PropertyMeta<C, P>) pm.getPropertyMeta().getPropertyClassMeta().newPropertyFinder(ConstantPredicate.<PropertyMeta<?, ?>>truePredicate()).findProperty(DefaultPropertyNameMatcher.of("0"), pm.getColumnDefinition().properties());
            final PropertyMapping<C, P, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>> pmchildProperttMeta = pm.propertyMeta(childProperty);
            IndexedSetter<PreparedStatement, P> setter = getSetter(pmchildProperttMeta);
            return new CollectionIndexFieldMapper<T, C, P>(setter, collectionGetter, sizeGetter, indexedGetter);
        }

        private <P, C> IndexedSetter<PreparedStatement, P> getSetter(PropertyMapping<C, P, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>> pm) {
            IndexedSetter<PreparedStatement, P> setter = null;
            IndexedSetterProperty indexedSetterProperty = pm.getColumnDefinition().lookFor(IndexedSetterProperty.class);
            if (indexedSetterProperty != null) {
                setter = (IndexedSetter<PreparedStatement, P>) indexedSetterProperty.getIndexedSetter();
            }
            if (setter == null) {
                setter = indexedSetterFactory(pm);
            }
            if (setter == null) {
                mapperConfig.mapperBuilderErrorHandler().accessorNotFound("Could not find setter for " + pm.getColumnKey() + " type " + pm.getPropertyMeta().getPropertyType() + " path " + pm.getPropertyMeta().getPath() + " See " + ErrorDoc.toUrl("PS_SETTER_NOT_FOUND"));
            }
            return setter;
        }

        private <P, C> IndexedSetter<PreparedStatement, P> indexedSetterFactory(PropertyMapping<C, P, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>> pm) {
            IndexedSetter<PreparedStatement, P> setter = null;
            final IndexedSetterFactoryProperty indexedSetterPropertyFactory = pm.getColumnDefinition().lookFor(IndexedSetterFactoryProperty.class);
            if (indexedSetterPropertyFactory != null) {
                IndexedSetterFactory<PreparedStatement, PropertyMapping<?, ?, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>>> setterFactory = (IndexedSetterFactory<PreparedStatement, PropertyMapping<?, ?, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>>>) indexedSetterPropertyFactory.getIndexedSetterFactory();
                setter = setterFactory.getIndexedSetter(pm);
            }
            if (setter == null) {
                setter = indexedSetterFactory.getIndexedSetter(pm);
            }
            if (setter == null) {
                final ClassMeta<P> classMeta = pm.getPropertyMeta().getPropertyClassMeta();
                if (classMeta instanceof ObjectClassMeta) {
                    ObjectClassMeta<P> ocm = (ObjectClassMeta<P>) classMeta;
                    if (ocm.getNumberOfProperties() == 1) {
                        PropertyMeta<P, ?> subProp = ocm.getFirstProperty();
                        final PropertyMapping<?, ?, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>> subPropertyMapping = pm.propertyMeta(subProp);
                        IndexedSetter<PreparedStatement, ?> subSetter = indexedSetterFactory(subPropertyMapping);
                        if (subSetter != null) {
                            setter = new PreparedStatementIndexSetterOnGetter<Object, P>((PreparedStatementIndexSetter<Object>) subSetter, (Getter<P, Object>) subProp.getGetter());
                        }
                    }
                }
            }
            return setter;
        }

        private <P> MultiIndexFieldMapper<T> newFieldMapper(PropertyMapping<T, P, JdbcColumnKey, FieldMapperColumnDefinition<JdbcColumnKey>> pm) {
            return new SingleIndexFieldMapper<T, P>(getSetter(pm), pm.getPropertyMeta().getGetter());
        }
    });
    return fields.toArray(new MultiIndexFieldMapper[0]);
}