How to use

BoundMapperFacade

in

ma.glasnost.orika

  @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);