Examples with DatastaxBooleanGetter org.simpleflatmapper.datastax.impl.getter.DatastaxBooleanGetter used on opensource projects

Example 1 with DatastaxBooleanGetter

use of org.simpleflatmapper.datastax.impl.getter.DatastaxBooleanGetter 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;
}