add support for concrete class constructor with Mapper(s) parameters

[lesaint]

To implement a clean mapping of a bean tree to another, it is necessary to reference Mapper of lower level bean in the Mappers of higher lever beans.

As such, it is necessary to declare in the concrete class a constructor which takes instance(s) of the lower level bean mappers.

DAMapping does not currently supports this kind of constructors and throws a compilation error.

scope of this issue

For simplicity reasons, support of this feature for concrete classes declaring method(s) annotated with @MapperFactory is out of the scope of this issue. A specific issue will be created.

Although, this feature is blocking writing code mapping trees of beans without using the Spring DI DAMapping support.

Implementation of this issue is a required step to implement DI integration with property injection.

detailed example

Given the following bean trees:

    |---------|                      |---------|
    |   Foo   |                      |   Bar   |
    |---------|                      |---------|
        < >                              < >
         |                                | 
         0                                0 
    |---------|                      |---------|
    |  Footi  |                      |  Barti  |
    |---------|                      |---------|

The expected code for concrete class implementing the mapping from Foo to Bar is a class with a constructor taking the Mapper interface to map Footi to Barti:

@Mapper
public class FooToBar {

  private final FootiToBartiMapper footiToBartiMapper;

  public FooToBar(FootiToBartiMapper footiToBartiMapper) {
    this.footiToBartiMapper = footiToBartiMapper;
  }

  @Nonnull
  public Bar transform(@Nullable Foo foo) {
    // mapping code here
  }
}

implementation

The generated FooToBarMapperImpl class should also have a constructor with the the Mapper interface to map Footi to Barti as a parameter:

public class FooToBarMapperImpl implements FooToBarMapper {
  private final FootiToBartiMapper footiToBartiMapper;

  public FooToBarMapperImpl(FootiToBartiMapper footiToBartiMapper) {
    this.footiToBartiMapper = footiToBartiMapper;
  }

  @Override
  @Nonnull
  public Bar transform(Foo foo) {
    return FooToBarMapperFactory.instance(footiToBartiMapper).transform(foo);
  }

}

The generated FooToBarMapperFactory must take the Mapper interface as a parameter to pass it to the concrete class instance:

class FooToBarMapperFactory {

    public static FooToBar instance(FootiToBartiMapper footiToBartiMapper) {
        return new FooToBar(footiToBartiMapper);
    }

}

[lesaint]

feature implemented with the following notes :

• since dev has been done after implementation of issue Factory class should be generated when there is at least one method annotated with @MapperFactory #15 , the MapperFactory part was not necessary any more
• the current implementation uses an name based algorithm to fix unresolved references to generate types but this can/must be improved as describe in issue remove name guessing algorithm from support for generated class/interface as dedicated class constructor parameter #18