org.mapstruct

Annotation Type InheritInverseConfiguration

@Target(value=METHOD)
 @Retention(value=CLASS)
public @interface InheritInverseConfiguration

Advises the code generator to apply all the Mappings from an inverse mapping method to the annotated method as well. An inverse mapping method is a method which has the annotated method's source type as target type (return type or indicated through a parameter annotated with MappingTarget) and the annotated method's target type as source type.

Any mappings given on the annotated method itself are added to those mappings inherited from the inverse method. In case of a conflict local mappings take precedence over inherited mappings.

If more than one matching inverse method exists, the name of the method to inherit the configuration from must be specified via name()

Mapping.expression(), Mapping.constant(), Mapping.defaultExpression() and Mapping.defaultValue() are not inverse inherited

Examples

 @Mapper
 public interface HumanMapper {
      Human toHuman(HumanDto humanDto);
      @InheritInverseConfiguration
      HumanDto toHumanDto(Human human);
 }
 

 // generates
 public class HumanMapperImpl implements HumanMapper {
      @Override
      public Human toHuman(HumanDto humanDto) {
          if ( humanDto == null ) {
              return null;
           }
          Human human = new Human();
          human.setName( humanDto.getName() );
          return human;
      }
      @Override
      public HumanDto toHumanDto(Human human) {
          if ( human == null ) {
              return null;
          }
          HumanDto humanDto = new HumanDto();
          humanDto.setName( human.getName() );
          return humanDto;
      }
 }
 

 @Mapper
 public interface CarMapper {

 @Mapping( target = "seatCount", source = "numberOfSeats")
 @Mapping( target = "enginePower", source = "engineClass", ignore=true) // NOTE: source specified as well
 CarDto carToDto(Car car);

 @InheritInverseConfiguration
 @Mapping(target = "numberOfSeats", ignore = true)
 // no need to specify a mapping with ignore for "engineClass": specifying source above will assume
 Car carDtoToCar(CarDto carDto);
 }
 

Author:

Sjaak Derksen

Optional Element Summary

Optional Elements

Modifier and Type	Optional Element and Description
String	name The name of the inverse mapping method to inherit the mappings from.

Element Detail

name

public abstract String name

The name of the inverse mapping method to inherit the mappings from. Needs only to be specified in case more than one inverse method with matching source and target type exists.

Returns:

The name of the inverse mapping method to inherit the mappings from.

Default:

""