public A mapReverse(B instanceB, A instanceA) { return wrapped.mapReverse(instanceB, instanceA); }
public A mapReverse(B instanceB, A instanceA, MappingContext context) { return wrapped.mapReverse(instanceB, instanceA, context); }
public A mapReverse(B instanceB) { return wrapped.mapReverse(instanceB); }
public A mapReverse(B instanceB, MappingContext context) { return wrapped.mapReverse(instanceB, context); }
@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()); }
GenericDto result = mapper.mapReverse(source);
@Test public void testInverseOneToManyMapping() { MapperFactory factory = MappingUtil.getMapperFactory(); ClassMapBuilder<PublisherDTO, Publisher> classMapBuilder = factory.classMap(PublisherDTO.class, Publisher.class); classMapBuilder.fieldMap("books").bInverse("publisher").add(); factory.registerClassMap(classMapBuilder.byDefault().toClassMap()); BoundMapperFacade<Publisher,PublisherDTO> mapper = factory.getMapperFacade(Publisher.class, PublisherDTO.class); BookDTO parisNoirDTO = new BookDTO(); parisNoirDTO.setTitle("Paris Noir"); BookDTO chiensFousDTO = new BookDTO(); chiensFousDTO.setTitle("Chiens Fous"); PublisherDTO publisherDTO = new PublisherDTO(); publisherDTO.setName("Asphalte Editions"); publisherDTO.getBooks().add(parisNoirDTO); publisherDTO.getBooks().add(chiensFousDTO); Publisher publisher = mapper.mapReverse(publisherDTO); Assert.assertTrue(publisher == publisher.getBooks().iterator().next().getPublisher()); }
readerDTO.setBooks(bookDTOs); Reader reader = mapper.mapReverse(readerDTO); Reader reader2 = mapper2.map(readerDTO);
@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)); }
@Test public void testInverseOneToOneMapping() { MapperFactory factory = MappingUtil.getMapperFactory(); ClassMapBuilder<PersonDTO, Person> classMapBuilder = factory.classMap(PersonDTO.class, Person.class); classMapBuilder.fieldMap("address").bInverse("person").add(); factory.registerClassMap(classMapBuilder.byDefault().toClassMap()); BoundMapperFacade<Person,PersonDTO> mapper = factory.getMapperFacade(Person.class, PersonDTO.class); AddressDTO addressDTO = new AddressDTO(); addressDTO.setLine1("5 rue Blida"); addressDTO.setLine2("20100 Casablanca"); PersonDTO personDTO = new PersonDTO(); personDTO.setFirstName("Khalil"); personDTO.setLastName("Gibran"); personDTO.setAddress(addressDTO); Person person = mapper.mapReverse(personDTO); Assert.assertEquals(personDTO.getFirstName(), person.getFirstName()); Assert.assertEquals(personDTO.getAddress().getLine1(), person.getAddress().getLine1()); Assert.assertTrue(person == person.getAddress().getPerson()); }