protected final void mapFields(final S source, final T target, final MappingContext<? super S> mappingContext) throws Exception { for (FieldMapper<S, T> fieldMapper : fieldMappers) { fieldMapper.mapTo(source, target, mappingContext); } }
@Override public void mapTo(S source, O target, MappingContext<? super S> context) throws Exception { for(FieldMapper<S, O> mapper : mappers) { mapper.mapTo(source, target, context); } }
public void mapFrom(S source, MappingContext<? super S> context) throws Exception { for(FieldMapper<S, GenericBuilder<S, T>> fm : genericBuilderFieldMappers) { fm.mapTo(source, this, context); } }
@Override public void mapTo(S source, O target, MappingContext<? super S> context) throws Exception { for(FieldMapper<S, O> mapper : mappers) { mapper.mapTo(source, target, context); } }
@Override protected final void mapToFields(S source, T target, final MappingContext<? super S> mappingContext) throws Exception { for (FieldMapper<S, T> constructorMapper : constructorMappers) { constructorMapper.mapTo(source, target, mappingContext); } mapFields(source, target, mappingContext); }
@Override public UDTValue convert(I in, Context context) throws Exception { if (in == null) return null; UDTValue udtValue = userType.newValue(); mapper.mapTo(in, udtValue, null); return udtValue; } }
@Override public TupleValue convert(I in, Context context) throws Exception { if (in == null) return null; TupleValue tv = tupleType.newValue(); mapper.mapTo(in, tv, null); return tv; } }
@Override public void mapTo(S source, T target, MappingContext<? super S> context) throws Exception { if (predicate.test(source)) { for(FieldMapper fm : targetFieldMappers) { fm.mapTo(source, target, context); } } } });
@Override public void mapTo(S source, T target, MappingContext<? super S> mappingContext) { try { delegate.mapTo(source, target, mappingContext); } catch(Exception e) { errorHandler.errorMappingField(key, source, target, e, mappingContext); } }
public BoundStatement mapTo(T object, BoundStatement boundStatement) { try { mapper.mapTo(object, boundStatement, null); } catch (Exception e) { ErrorHelper.rethrow(e); } return boundStatement; }
@Override public void bindTo(T value, PreparedStatement ps) throws SQLException { try { queryPreparer.mapper().mapTo(value, ps, null); } catch (Exception e) { ErrorHelper.rethrow(e); } } }
@Override public void bindTo(T value, PreparedStatement ps) throws SQLException { try { queryPreparer.mapper().mapTo(value, ps, null); } catch (Exception e) { ErrorHelper.rethrow(e); } } }
@Override public void set(SettableByIndexData target, T value) throws Exception { if (value == null) { target.setToNull(index); } else { UDTValue udtValue = udtType.newValue(); mapper.mapTo(value, udtValue, null); target.setUDTValue(index, udtValue); } }
private <T> void assertPrimitiveSetter(FieldMapper<Object, T> fieldMapper, T object, String getter, Class<?> primitiveInterface, Object... expected) throws Exception { assertTrue("Expect " + fieldMapper + " to be an newInstance of " + primitiveInterface, primitiveInterface.isInstance(fieldMapper)); Method getterMethod = object.getClass().getMethod(getter); assertEquals(expected[0], getterMethod.invoke(object)); fieldMapper.mapTo(null, object, null); assertEquals(expected[1], getterMethod.invoke(object)); }
private <T> void testMapping(T object, String property, String expectedValue) throws Exception { PropertyMapping<T, String, SampleFieldKey> pm = ConstantSourceFieldMapperFactoryImplTest.createPropertyMapping((Class<T>) object.getClass(), property); FieldMapper<T, Appendable> fieldMapper = factory.newFieldMapper(pm, null, RethrowMapperBuilderErrorHandler.INSTANCE); StringBuilder sb = new StringBuilder(); fieldMapper.mapTo(object, sb, null); assertEquals(expectedValue, sb.toString()); }
protected <T, P> void newFieldMapperAndMapToPS(Getter<T, P> getter, Class<P> clazz, int sqlType, Object... properties) throws Exception { PropertyMapping<T, P, JdbcColumnKey> propertyMapping = newPropertyMapping(getter, clazz, sqlType, properties); FieldMapper<T, PreparedStatement> fieldMapper = factory.<T, P>newFieldMapper(propertyMapping, null, RethrowMapperBuilderErrorHandler.INSTANCE); fieldMapper.mapTo(null, ps, null); }
@Test public void testDirectMeta() throws Exception { PreparedStatementMapperBuilder<DMClass> mapperBuilder = JdbcMapperFactory.newInstance().buildFrom(DMClass.class); mapperBuilder.addColumn("time"); FieldMapper<DMClass, PreparedStatement> mapper = mapperBuilder.mapper(); DMClass dmClass = new DMClass(); dmClass.setTime(new Date()); PreparedStatement ps = mock(PreparedStatement.class); mapper.mapTo(dmClass, ps, null); verify(ps).setTimestamp(1, new Timestamp(dmClass.getTime().getTime())); } @Test
@Test public void testCustomGetterOnNonExistantProp() throws Exception { PreparedStatementMapperBuilder<Object> mapperBuilder = JdbcMapperFactory.newInstance() .addColumnProperty("text", new ConstantValueProperty<String>("value2", String.class)) .buildFrom(Object.class); mapperBuilder.addColumn("text"); FieldMapper<Object, PreparedStatement> mapper = mapperBuilder.mapper(); PreparedStatement ps = mock(PreparedStatement.class); mapper.mapTo(new Object(), ps, null); verify(ps).setString(1, "value2"); } }
@Test public void testGetterOnlyMethod() throws Exception { PreparedStatementMapperBuilder<DMClass> mapperBuilder = JdbcMapperFactory.newInstance().buildFrom(DMClass.class); mapperBuilder.addColumn("value"); FieldMapper<DMClass, PreparedStatement> mapper = mapperBuilder.mapper(); DMClass dmClass = new DMClass(); PreparedStatement ps = mock(PreparedStatement.class); mapper.mapTo(dmClass, ps, null); verify(ps).setString(1, "value"); }
@Test public void testRename() throws Exception { PreparedStatementMapperBuilder<DMClass> mapperBuilder = JdbcMapperFactory.newInstance() .addAlias("val", "value") .buildFrom(DMClass.class); mapperBuilder.addColumn("val"); FieldMapper<DMClass, PreparedStatement> mapper = mapperBuilder.mapper(); DMClass dmClass = new DMClass(); PreparedStatement ps = mock(PreparedStatement.class); mapper.mapTo(dmClass, ps, null); verify(ps).setString(1, "value"); }