@Override public OrderDTO map(Order source) { return orderMapper.map(source); } };
for (int i=0, len = usedMapperFacades.size(); i < len; ++i) { BoundMapperFacade<Object,Object> dedicatedFacade = usedMapperFacades.get(i); if (dedicatedFacade.getAType().equals(sourceType) && dedicatedFacade.getBType().equals(destinationType)) { result.index = i; break; } else if (dedicatedFacade.getAType().equals(destinationType) && dedicatedFacade.getBType().equals(sourceType)) { result.index = i; result.isReversed = true;
public A mapReverse(B instanceB, A instanceA, MappingContext context) { return wrapped.mapReverse(instanceB, instanceA, context); }
GenericDto result = mapper.mapReverse(source); MapWithoutSetter mapBack = mapper.map(result); Assert.assertTrue(source.getScores().keySet().containsAll(mapBack.getScores().keySet())); Assert.assertTrue(mapBack.getScores().keySet().containsAll(source.getScores().keySet()));
public Type<B> getBType() { return wrapped.getBType(); }
public Type<A> getAType() { return wrapped.getAType(); }
public A newObjectReverse(B source, MappingContext context) { return wrapped.newObjectReverse(source, context); } }
public B newObject(A source, MappingContext context) { return wrapped.newObject(source, context); }
readerDTO.setBooks(bookDTOs); Reader reader = mapper.mapReverse(readerDTO); Reader reader2 = mapper2.map(readerDTO);
@Override public T copy(F source) { checkNotNull(source, "source bean cannot be null!"); try { return copier.map(source); } catch (Exception e) { throw new CopierException("create object fail, class: " + targetClass.getName(), e); } }
@Test public void testInverseManyToOneMapping() { MapperFactory factory = MappingUtil.getMapperFactory(); ClassMapBuilder<BookDTO, Book> classMapBuilder = factory.classMap(BookDTO.class, Book.class); classMapBuilder.fieldMap("author").bInverse("books").add(); factory.registerClassMap(classMapBuilder.byDefault().toClassMap()); /* * Doesn't matter which direction you ask for the bound mapper; */ BoundMapperFacade<Book, BookDTO> mapper = factory.getMapperFacade(Book.class, BookDTO.class); BoundMapperFacade<BookDTO, Book> mapper2 = factory.getMapperFacade(BookDTO.class, Book.class); AuthorDTO authorDTO = new AuthorDTO(); authorDTO.setFirstName("Khalil"); authorDTO.setLastName("Gibran"); BookDTO bookDTO = new BookDTO(); bookDTO.setTitle("The Prophet"); bookDTO.setAuthor(authorDTO); Book book = mapper.mapReverse(bookDTO); Book book2 = mapper2.map(bookDTO); Assert.assertTrue(book.getAuthor().getBooks().contains(book)); Assert.assertTrue(book2.getAuthor().getBooks().contains(book2)); }
for (int i=0, len = usedMapperFacades.size(); i < len; ++i) { BoundMapperFacade<Object,Object> dedicatedFacade = usedMapperFacades.get(i); if (dedicatedFacade.getAType().equals(sourceType) && dedicatedFacade.getBType().equals(destinationType)) { result.index = i; break; } else if (dedicatedFacade.getAType().equals(destinationType) && dedicatedFacade.getBType().equals(sourceType)) { result.index = i; result.isReversed = true;
public A mapReverse(B instanceB) { return wrapped.mapReverse(instanceB); }
@Override public void copy(F source, T target) { checkNotNull(source, "source bean cannot be null!"); checkNotNull(target, "target bean cannot be null!"); try { copier.map(source, target); } catch (Exception e) { throw new CopierException("create object fail, class: " + targetClass.getName(), e); } }
public A mapReverse(B instanceB, MappingContext context) { return wrapped.mapReverse(instanceB, context); }
@Test public void testMapToMapGeneration_noSetter() throws Exception { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap( factory.classMap(MapWithSetter.class, MapWithoutSetter.class) .field("testScores", "scores").byDefault()); BoundMapperFacade<MapWithSetter, MapWithoutSetter> mapper = factory.getMapperFacade(MapWithSetter.class, MapWithoutSetter.class); MapWithSetter source = new MapWithSetter(); Map<String, Integer> testScores = new LinkedHashMap<String, Integer>(); testScores.put("A", 90); testScores.put("B", 80); testScores.put("C", 70); source.setTestScores(testScores); MapWithoutSetter result = mapper.map(source); Assert.assertNotNull(result); Assert.assertNotNull(result.getScores()); for (Entry<String, Integer> entry: testScores.entrySet()) { Assert.assertEquals(entry.getValue().toString(), result.getScores().get(entry.getKey())); } }
public A mapReverse(B instanceB, A instanceA) { return wrapped.mapReverse(instanceB, instanceA); }
@Test public void testMapToMapGeneration() throws Exception { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap( factory.classMap(MapWithSetter.class, MapWithSetterDto.class) .field("testScores", "scores").byDefault()); BoundMapperFacade<MapWithSetter, MapWithSetterDto> mapper = factory.getMapperFacade(MapWithSetter.class, MapWithSetterDto.class); MapWithSetter source = new MapWithSetter(); Map<String, Integer> testScores = new LinkedHashMap<String, Integer>(); testScores.put("A", 90); testScores.put("B", 80); testScores.put("C", 70); source.setTestScores(testScores); MapWithSetterDto result = mapper.map(source); Assert.assertNotNull(result); Assert.assertNotNull(result.getScores()); for (Entry<String, Integer> entry: testScores.entrySet()) { Assert.assertEquals(entry.getValue(), result.getScores().get(entry.getKey())); } }
@Test public void testListToArray() { BoundMapperFacade<A,D> mapperFacade = MappingUtil.getMapperFactory().getMapperFacade(A.class, D.class); D source = new D(); source.setBuffer(Arrays.asList((byte)1,(byte)2,(byte)3,(byte)4)); A destination = mapperFacade.mapReverse(source); Assert.assertArrayEquals(new byte[] {(byte)1,(byte)2,(byte)3,(byte)4}, destination.getBuffer()); }
source.setIntArray(GeneratedObjectBase.intArray(numericScores)); MapWithoutSetter result = mapper.map(source);