Can't get MapStruct to work with Enum Inheritance & @TargetTytpe

Question

Here is my sample setup:

interface EnumMessage {
  boolean carrier(String message);

  String getValue();

  default String getMessage() {
    return getValue().toUpperCase();
  }
}

enum EnumMessageA implements EnumMessage {
  GREAT("You are doing great"),
  GOOD("You are doing good"),
  OK("You are doing ok");

  private String value;

  EnumMessageA(final String value) {
    this.value = value;
  }

  @Override
  public String getValue() {
    return value;
  }

  @Override
  public boolean carrier(final String message) {
    return this.value.equals(message);
  }
}

class SourceX {
  public String name;
  public String message;
}

class TargetX {
  public String name;
  public EnumMessageA messageA;
}

@Mapper
interface EnumMapper {
  EnumMapper INSTANCE = Mappers.getMapper(EnumMapper.class);

  @Mapping(source = "message", target = "messageA", qualifiedByName = "stringToEnum")
  TargetX toTarget(SourceX source);

  @Mapping(source = "messageA", target = "message", qualifiedByName = "enumToString")
  SourceX toSource(TargetX target);

  @Named("stringToEnum")
  default <T extends EnumMessage> T mapStringToEnum(
      final String message, @TargetType final Class<T> enumClass) {
    final T[] values = enumClass.getEnumConstants();
    return Arrays.stream(values)
        .filter(enumValue -> enumValue.carrier(message))
        .findFirst()
        .orElse(null);
  }

  @Named("enumToString")
  default <T extends EnumMessage> String mapEnumToString(final T enumValue) {
    return enumValue.getMessage();
  }
}

I can't get the test to pass.

 public class EnumMapperTest {
    
      @Test
      void checkMapping() {
        TargetX target = new TargetX();
        target.name = "MapStructTesting";
        target.messageA = EnumMessageA.GREAT;
        Assertions.assertEquals(
            "You are doing great".toUpperCase(), EnumMapper.INSTANCE.toSource(target).message);
    
        SourceX source = new SourceX();
        source.name = "MapStructTesting";
        source.message = "You are doing ok";
        Assertions.assertEquals(EnumMessageA.OK, EnumMapper.INSTANCE.toTarget(source).messageA);
      }
    }

I tried with or without qualifiedByName, but can't get MapStruct to use the mapStringToEnum method.

I'm not sure if this is a bug in MapStruct not working with Enum inheritance when using @TargetType or I am missing something.

• When using @Mapping(source = "message", target = "messageA", qualifiedByName = "stringToEnum") , it gives compile time error:

    error: Qualifier error. No method found annotated with @Named#value: [ stringToEnum ]. See https://mapstruct.org/faq/#qualifier for more info.
      @Mapping(source = "message", target = "messageA", qualifiedByName = "stringToEnum")
     error: Can't map property "String message" to "EnumMessageA messageA". Consider to declare/implement a mapping method: "EnumMessageA map(String value)".
      @Mapping(source = "message", target = "messageA", qualifiedByName = "stringToEnum")

• When using @Mapping(source = "message", target = "messageA") or with resultType @Mapping(source = "message", target = "messageA", resultType = EnumMessage.class, the generated implementation ignores the provided method.

class EnumMapperImpl implements EnumMapper {

    @Override
    public TargetX toTarget(SourceX source) {
        if ( source == null ) {
            return null;
        }

        TargetX targetX = new TargetX();

        if ( source.message != null ) {
            targetX.messageA = Enum.valueOf( EnumMessageA.class, source.message );
        }
        targetX.name = source.name;

        return targetX;
    }

    @Override
    public SourceX toSource(TargetX target) {
        if ( target == null ) {
            return null;
        }

        SourceX sourceX = new SourceX();

        sourceX.message = mapEnumToString( target.messageA );
        sourceX.name = target.name;

        return sourceX;
    }
}

I am open to suggestions if there is a more elegant way to generalize the mapping. NOTE: I can't use the @BeforeMapping / @AfterMapping as I have many enum types to be mapped, thus looking for an implicit or generalized solution.

Answer 1

Figured out, as well raised a bug with the MapStruct team on GitHub.

To get it working, the following must meet:

1. mapper method must be static
2. qualifiedByName attribute is certainly required, even if I change the generic signature to be <T extends Enum<T> & EnumMessage>

So my modified code looks like this:

@Mapper
public class EnumMapperHelper {

  @Named("stringToEnum")
  public static <T extends EnumMessage> T mapStringToEnum(
      final String message, @TargetType final Class<T> enumClass) {
    final T[] values = enumClass.getEnumConstants();
    return Arrays.stream(values)
        .filter(enumValue -> enumValue.carrier(message))
        .findFirst()
        .orElse(null);
  }

  @Named("enumToString")
  //this doesn't have to be static but yes the @Qualifier is required
  public static <T extends EnumMessage> String mapEnumToString(final T enumValue) {
    return enumValue.getMessage();
  }
}


@Mapper(uses = EnumMapperHelper.class) 
interface EnumMapper {
  EnumMapper INSTANCE = Mappers.getMapper(EnumMapper.class);

  @Mapping(source = "message", target = "messageA", qualifiedByName = "stringToEnum")
  TargetX toTarget(SourceX source);

  @Mapping(source = "messageA", target = "message", qualifiedByName = "enumToString")
  SourceX toSource(TargetX target);
}