@Mapper
public interface MyMapper {

    MyMapper INSTANCE = Mappers.getMapper( MyMapper.class );

    Employee map(EmployeeDto employee);

    @Condition
    default <T> boolean isNotEmpty(Collection<T> collection, @TargetPropertyName String propName) {
        if ( "addresses".equalsIgnoreCase( propName ) ) {
            return false;
        }
        return collection != null && !collection.isEmpty();
    }

    @Condition
    default boolean isNotBlank(String value, @TargetPropertyName String propName) {
        if ( propName.equalsIgnoreCase( "lastName" ) ) {
            return false;
        }
        return value != null && !value.trim().isEmpty();
    }
}

@Mapper
public interface MyMapper {

    MyMapper INSTANCE = Mappers.getMapper( MyMapper.class );

    Employee map(EmployeeDto employee, @Context PresenceUtils utils);

    Address map(AddressDto addressDto, @Context PresenceUtils utils);

    class PresenceUtils {
        Set<String> visited = new LinkedHashSet<>();

        @Condition
        public boolean decide(String value, @TargetPropertyName String propName) {
            return true; //decide if continue mapping
        }
    }
}

interface Entity {}
interface Dto {}

class Employee implements Entity { // setters and getters ommited
    String name;
    Employee boss;
    Address address;
    List<Employee> subordinates;
    String title;
}

class Address implements Entity { // setters and getters ommited
    String street;
}

class EmployeeDto implements Dto { // default constructor, setters and getters ommited
    String name;
    EmployeeDto boss;
    AddressDto address;
    List<EmployeeDto> subordinates;
    String title;

    public EmployeeDto(String name, EmployeeDto boss, AddressDto address) {
        this.name = name;
        this.boss = boss;
        this.address = address;
    }

    public EmployeeDto(String name, AddressDto address, List<EmployeeDto> subordinates) {
        this.name = name;
        this.address = address;
        this.subordinates = subordinates;
    }
}

class AddressDto implements Dto { // default constructor, setters and getters ommited
    String street;
    
    public AddressDto(String street) {
        this.street = street;
    }
}

class PathSegment {
    String name;
    boolean cycleDetected;

    public PathSegment(String name, boolean cycleDetected) {
        this.name = name;
        this.cycleDetected = cycleDetected;
    }
}

class CollectionPathSegment extends PathSegment {
    int index;

    public CollectionPathSegment(String name, boolean cycleDetected) {
        super( name, cycleDetected );
    }
}

class CollectionElementPathSegment extends PathSegment {
    int index;
    public CollectionElementPathSegment(String name, int index, boolean cycleDetected) {
        super( name, cycleDetected );
        this.index = index;
    }
}

class MapContext {
    Set<String> ignoreProps = new HashSet<>();
    Set<Integer> mapped = new HashSet<>();
    Deque<PathSegment> path = new LinkedList<>();
    Deque<String> visited = new LinkedList<>();
    String lastProp = null;

    private String pathToString() {
        StringBuilder strPath = new StringBuilder();
        for ( PathSegment segment : path ) {
            if ( segment instanceof CollectionElementPathSegment ) {
                strPath.append( segment.name );
            } else {
                if ( strPath.length() > 0 ) {
                    strPath.append( "." );
                }
                strPath.append( segment.name );
            }
        }
        if (path.isEmpty()) {
            return lastProp;
        }
        strPath.append( "." );
        strPath.append( lastProp );
        return strPath.toString();
    }

    @Condition
    public boolean collect(@TargetPropertyName String propName) {
        PathSegment segment = path.peekLast();
        if ( ignoreProps.contains( propName ) || (segment != null && segment.cycleDetected)) {
            return false;
        }
        this.lastProp = propName;
        this.visited.offerLast( pathToString() );
        return true;
    }
}

interface FirmMapper<E extends Entity, D extends Dto> {

    E map(D dto, @Context MapContext ctx);

    @BeforeMapping
    default void before(Object dto, @Context MapContext ctx) {
        if ( dto == null ) {
            return;
        }
        boolean cycleDetected = !ctx.mapped.add( dto.hashCode() );

        if ( ctx.lastProp == null ) {
            return;
        }
        if ( dto instanceof Collection ) {
            ctx.path.offerLast( new CollectionPathSegment( ctx.lastProp, cycleDetected ) );
        } else {
            PathSegment segment = ctx.path.peekLast();
            if ( segment instanceof CollectionPathSegment ) {
                ctx.path.offerLast(
                        new CollectionElementPathSegment(
                                "[" + ( (CollectionPathSegment) segment ).index + "]",
                                ( (CollectionPathSegment) segment ).index,
                                cycleDetected
                        )
                );
                ( (CollectionPathSegment) segment ).index++;
            } else {
                ctx.path.offerLast( new PathSegment( ctx.lastProp, cycleDetected ) );
            }
        }
    }

    @AfterMapping
    default void after(Object dto, @Context MapContext ctx) {
        ctx.path.pollLast();
        PathSegment segment = ctx.path.peekLast();
        if ( segment != null ) {
            ctx.lastProp = segment.name;
        } else {
            ctx.lastProp = null;
        }
    }
}

@Mapper
interface EmployeeMapper extends FirmMapper<Employee, EmployeeDto> {
    EmployeeMapper INSTANCE = Mappers.getMapper( EmployeeMapper.class );
}

@Mapper
interface AddressMapper extends FirmMapper<Address, AddressDto> {
    AddressMapper INSTANCE = Mappers.getMapper( AddressMapper.class );
}

// ... more mappers

public void test) {
    EmployeeMapper mapper = EmployeeMapper.INSTANCE;
    MapContext context = new MapContext();
    //context.ignoreProps.add( "boss" ); // glob - like exclude / include could be implemented

    EmployeeDto bossDto = new EmployeeDto( "Boss", new AddressDto("Testing st. 18"), new ArrayList<>() );
    bossDto.subordinates.add( new EmployeeDto( "Employee1", bossDto, new AddressDto("Street 1") ) );
    bossDto.subordinates.add( new EmployeeDto( "Employee2", bossDto, new AddressDto("Street 2") ) );
    bossDto.subordinates.add( new EmployeeDto( "Employee3", bossDto, new AddressDto("Street 3") ) );

    Employee boss = mapper.map( bossDto, context );
    assertThat( List.of(
            "name",
            "boss",
            "address",
            "address.street",
            "subordinates",
            "subordinates[0].name",
            "subordinates[0].boss",
            "subordinates[0].address",
            "subordinates[0].address.street",
            "subordinates[0].subordinates",
            "subordinates[0].title",
            "subordinates[1].name",
            "subordinates[1].boss",
            "subordinates[1].address",
            "subordinates[1].address.street",
            "subordinates[1].subordinates",
            "subordinates[1].title",
            "subordinates[2].name",
            "subordinates[2].boss",
            "subordinates[2].address",
            "subordinates[2].address.street",
            "subordinates[2].subordinates",
            "subordinates[2].title",
            "title"
    ) ).isEqualTo( context.visited );
}