public final GetterFactory<S, K> findFactoryFor(Type targetType) { Class<?> target = TypeHelper.toClass(targetType); GetterFactory<S, K> getterFactory = factoryPerType.get(target); if (getterFactory != null) { return getterFactory; } return null; }
@Override public Type getType(Type targetType) { Class<?> type = field.getType(); if (Object.class.equals(type)) { if (TypeHelper.isArray(targetType)) { return java.sql.Array.class; } else if (TypeHelper.isAssignable(List.class, targetType)) { return java.sql.Array.class; }else if (TypeHelper.isAssignable(java.sql.Array.class, targetType)) { return java.sql.Array.class; } } return type; }
public static int getTargetScore(Type from, Type target) { if (!TypeHelper.isAssignable(target, from)) { return NOT_COMPATIBLE; } if (TypeHelper.areEquals(from, target)) { return MAX_SCORE; } return Math.max(MAX_SCORE - distanceToParent(from, target), 0); }
private static boolean allowToStringConverter(Type type) { return TypeHelper.isPrimitive(type) || TypeHelper.isEnum(type) || TypeHelper.isInPackage(type, new Predicate<String>() { @Override public boolean test(String s) { return s.startsWith("java."); } }) ; }
public static Class<?> toBoxedClass(Type type) { return TypeHelper.toBoxedClass(toClass(type)); }
public static boolean isAssignable(Type type, Type from) { return isAssignable(TypeHelper.toBoxedClass(type), from); }
if (TypeHelper.isEnum(propertyType)) { if (TypeHelper.areEquals(type, String.class)) { return (Setter<SettableByIndexData, P>) new StringEnumSettableDataSetter(arg.getColumnKey().getIndex()); } else { this.factoryPerClass.get(TypeHelper.toClass(type)); if (!TypeHelper.areEquals(TypeHelper.toBoxedClass(type), TypeHelper.toBoxedClass(propertyType))) { ContextualConverter<?, ?> converter = getConverter(propertyType, TypeHelper.toClass(type), dataType, arg.getColumnDefinition(), contextFactoryBuilder); if (converter != null) { setter = (Setter<SettableByIndexData, P>) new ConvertDelegateSetter<SettableByIndexData, Object, P>(setter, (ContextualConverter<Object, P>) converter); } else if (TypeHelper.isAssignable(List.class, type) && TypeHelper.isAssignable(List.class, propertyType)) { Type lEltType = TypeHelper.getComponentTypeOfListOrArray(propertyType); if (TypeHelper.areEquals(lEltType, dEltType)) { setter = new ListSettableDataSetter(arg.getColumnKey().getIndex()); } else { } else if (TypeHelper.isAssignable(Set.class, type) && TypeHelper.isAssignable(Set.class, propertyType)) { Type lEltType = TypeHelper.getComponentTypeOfListOrArray(propertyType); if (TypeHelper.areEquals(lEltType, dEltType)) { setter = new SetSettableDataSetter(arg.getColumnKey().getIndex()); } else { } else if (TypeHelper.isAssignable(Map.class, type) && TypeHelper.isAssignable(Map.class, propertyType)) { TypeHelper.MapEntryTypes keyValueTypeOfMap = TypeHelper.getKeyValueTypeOfMap(propertyType);
ContextualIndexedSetter<PreparedStatement, T> setter = null; if (TypeHelper.isEnum(propertyType)) { switch (arg.getColumnKey().getSqlType(arg.getColumnDefinition().properties())) { case Types.NUMERIC: Factory setterFactory = this.factoryPerClass.get(TypeHelper.toClass(propertyType)); if (setterFactory != null) { setter = setterFactory.<T>getIndexedSetter(arg.getColumnKey(), contextFactoryBuilder, arg.getColumnDefinition().properties()); if (setter == null && TypeHelper.isAssignable(SQLData.class, propertyType)) { setter = (ContextualIndexedSetter<PreparedStatement, T>) new ObjectPreparedStatementIndexSetter();
@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()); Type elementType = TypeHelper.getComponentTypeOfListOrArray(target); Class<?> dataTypeClass = Object.class; Class<?> dataTypeElt = null; dataTypeElt = TypeHelper.toClass(elementType); if (TypeHelper.areEquals(elementType, dataTypeElt)) { if (Set.class.equals(dataTypeClass)) { if (targetClass.isAssignableFrom(dataTypeClass)) { return new DatastaxSetGetter(key.getIndex(), TypeHelper.toClass(elementType)); return new DatastaxListGetter(key.getIndex(), TypeHelper.toClass(elementType)); TypeHelper.MapEntryTypes keyValueTypeOfMap = TypeHelper.getKeyValueTypeOfMap(target); dtKeyType = TypeHelper.toClass(keyValueTypeOfMap.getKeyType()); dtValueType = TypeHelper.toClass(keyValueTypeOfMap.getValueType()); 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 { ContextualConverter<?, ?> keyConverter = getConverter(keyValueTypeOfMap.getKeyType(), dtKeyType, dtKey);
@SuppressWarnings("unchecked") public <S, T, K extends FieldKey<K>> BiInstantiator<S, MappingContext<?>, T> getBiInstantiator(final Type source, final Type target, final PropertyMappingsBuilder<T, K> propertyMappingsBuilder, final Map<Parameter, ContextualGetter<? super S, ?>> constructorParameterGetterMap, final ContextualGetterFactory<? super S, K> getterFactory, final boolean useAsmIfEnabled, final boolean builderIgnoresNullValues, final MappingContextFactoryBuilder<? super S, K> mappingContextFactoryBuilder) throws NoSuchMethodException { if (propertyMappingsBuilder.isSelfProperty()) { ContextualGetter getter = propertyMappingsBuilder.forEachProperties(new ForEachCallBack<PropertyMapping<T, ?, K>>() { public ContextualGetter getter; @Override public void handle(PropertyMapping<T, ?, K> propertyMapping) { getter = getterFactory.newGetter(propertyMapping.getPropertyMeta().getPropertyType(), propertyMapping.getColumnKey(), mappingContextFactoryBuilder, propertyMapping.getColumnDefinition().properties()); } }).getter; return new ContextualGetterBiInstantiator<S, T>(getter); } if (TypeHelper.isArray(target)) { return instantiatorFactory.<S, MappingContext<?>, T>getArrayBiInstantiator(TypeHelper.toClass(TypeHelper.getComponentTypeOfListOrArray(target)), propertyMappingsBuilder.forEachProperties(new CalculateMaxIndex<T, K>()).maxIndex + 1); } else { List<InstantiatorDefinition> instantiatorDefinitions = propertyMappingsBuilder.getPropertyFinder().getEligibleInstantiatorDefinitions(); return instantiatorFactory. <S, MappingContext<?>, T> getBiInstantiator( target, TypeHelper.<S>toClass(source), MappingContext.class, instantiatorDefinitions, convertToBiInstantiator(constructorParameterGetterMap), useAsmIfEnabled, builderIgnoresNullValues); } }
@SuppressWarnings("unchecked") public <T, E> IntFactory<Getter<T, E>> newGetterFactory() { if (TypeHelper.isArray(type)) { Type elementType = TypeHelper.getComponentTypeOfListOrArray(type); if (TypeHelper.isPrimitive(elementType)) { if (boolean.class.equals(elementType)) { return new IntFactory<Getter<T, E>>() { } else if (TypeHelper.isAssignable(List.class, instInfo.intermediateType)) { return new IntFactory<Getter<T, E>>() { @Override
public int score(Type type) { for(int i = 0; i < affinities.length; i++) { if (TypeHelper.isAssignable(type, affinities[i])) { return affinities.length - i; } } return -1; } }
private static InstantiatorDefinition getConstructor(Type type) { if (TypeHelper.isArray(type)) { return null; } else { try { return new ExecutableInstantiatorDefinition(TypeHelper.toClass(type).getDeclaredConstructor()); } catch (NoSuchMethodException e) { throw new IllegalArgumentException("No empty constructor for " + type); } } }
public static String toAsmType(final Type type) { if (TypeHelper.isPrimitive(type)) { return primitivesType.get(TypeHelper.toClass(type)); } return toAsmType(TypeHelper.toClass(type).getName()); }
@Override public ContextualConverter<? super Array, ? extends Object> newConverter(ConvertingTypes targetedTypes, ContextFactoryBuilder contextFactoryBuilder, Object... params) { Type elementType = TypeHelper.getComponentTypeOfListOrArray(targetedTypes.getTo()); Getter<? super ResultSet, ?> getter = ResultSetGetterFactory.INSTANCE.newGetter(elementType, new JdbcColumnKey("elt", 2), params); return new SqlArrayToJavaArrayConverter<Object>(TypeHelper.<Object>toClass(elementType), getter); }
@SuppressWarnings("unchecked") @Override public <P> Getter<Row, P> newGetter(Type target, CsvColumnKey key, Object... properties) { Class<P> targetClass = TypeHelper.toClass(target); if (TypeHelper.isEnum(target)) { return new PoiEnumGetter(key.getIndex(), TypeHelper.toClass(target)); } final GetterFactory<Row, CsvColumnKey> rowGetterFactory = getterFactories.findFactoryFor(targetClass); Getter<Row, P> getter = null; if (rowGetterFactory != null) { getter = rowGetterFactory.newGetter(target, key, properties); } if (getter != null) { return getter; } return null; } }
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public <P> Getter<R, P> newGetter(Type genericType, JooqFieldKey key, Object... properties) { Class<P> propertyClass = TypeHelper.toClass(genericType); if (TypeHelper.areCompatible(propertyClass, TypeHelper.toClass(key.getType(genericType)))) { return new RecordGetter<R, P>(key.getIndex()); } return null; }
@Override public boolean supports(Type type) { return TypeHelper.areEquals(type, Set.class) ; } @Override
if (TypeHelper.isPrimitive(type) && !columnDefinition.has(FormatProperty.class)) { if (getter instanceof BooleanGetter) { return new BooleanConstantTargetFieldMapper<S, Appendable>((BooleanGetter<? super S>) getter, new BooleanAppendableSetter(cellWriter)); if (TypeHelper.isEnum(type) && columnDefinition.has(EnumOrdinalFormatProperty.class)) { setter = (ContextualSetter<Appendable, ? super P>) new EnumOrdinalAppendableSetter(cellWriter); } else if (TypeHelper.areEquals(type, Date.class)) { String df = DEFAULT_DATE_FORMAT;
private static <O, I> Type getInType(ContextualConverter<I, O> converter) { Type[] types = TypeHelper.getGenericParameterForClass(converter.getClass(), ContextualConverter.class); if ( types == null) { return Object.class; } else { return types[0]; } } }