import dev.alexengrig.metter.annotation.GetterSupplier;
import dev.alexengrig.metter.annotation.SetterSupplier;

@GetterSupplier
@SetterSupplier
public class Domain {
    private int integer;
    private boolean bool;
    private String string;

    public int getInteger() {
        return integer;
    }

    public void setInteger(int integer) {
        this.integer = integer;
    }

    public boolean isBool() {
        return bool;
    }

    public void setBool(boolean bool) {
        this.bool = bool;
    }

    public String getString() {
        return string;
    }

    public void setString(String string) {
        this.string = string;
    }
}

import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;

public class DomainService {
    private final Map<String, Function<Domain, Object>> getterByField = new DomainGetterSupplier().get();
    private final Map<String, BiConsumer<Domain, Object>> setterByField = new DomainSetterSupplier().get();

    public void printFieldValues(Domain domain) {
        getterByField.forEach((field, getter) -> System.out.println(field   " = "   getter.apply(domain)));
    }

    public void transfer(Domain from, Domain to) {
        setterByField.forEach((field, setter) -> setter.accept(to, getterByField.get(field).apply(from)));
    }
}

import java.util.Collections;
import java.util.Map;
import java.util.function.Function;

public class CustomDomainGetterSupplier extends DomainGetterSupplier {
    @Override
    protected Map<String, Function<Domain, Object>> createMap() {
        Map<String, Function<Domain, Object>> generatedMap = super.createMap();
        generatedMap.put("name", domain -> "Name: domain.toString()");
        return Collections.unmodifiableMap(generatedMap);
    }

    public Function<Domain, Object> getGetter(String field) {
        return this.getterByField.get(field);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ApplicationConfiguration {
    @Bean
    public Map<String, Function<Domain, Object>> getterByField() {
        return new DomainGetterSupplier().get();
    }

    @Bean
    public Map<String, BiConsumer<Domain, Object>> setterByField() {
        return new DomainSetterSupplier().get();
    }
}

class Man {
    private String name;
    private int age;

    /*Getters and Setters*/
}

import java.util.StringJoiner;

class ManualManChangeLogGenerator extends BaseChangeLogGenerator<Man> {
    @Override
    public String generate(Man man, Man newMan) {
        StringJoiner joiner = new StringJoiner("\n");
        if (!man.getName().equals(newMan.getName())) {
            joiner.add(changeLog("name", man.getName(), newMan.getName()));
        }
        if (man.getAge() != newMan.getAge()) {
            joiner.add(changeLog("age", man.getAge(), newMan.getAge()));
        }
        return joiner.toString();
    }
}

import java.util.*;
import java.util.function.Function;

class MapManChangeLogGenerator extends BaseChangeLogGenerator<Man> {
    protected Map<String, Function<Man, Object>> getterByField = createMap();

    protected Map<String, Function<Man, Object>> createMap() {
        return new HashMap<String, Function<Man, Object>>() {{
            put("name", Man::getName);
            put("age", Man::getAge);
        }};
    }

    @Override
    public String generate(Man man, Man newMan) {
        StringJoiner joiner = new StringJoiner("\n");
        getterByField.forEach((field, getter) -> {
            Object value = getter.apply(man);
            Object newValue = getter.apply(newMan);
            if (!Objects.equals(value, newValue)) {
                joiner.add(changeLog(field, value, newValue));
            }
        });
        return joiner.toString();
    }
}

import java.lang.reflect.*;
import java.util.*;
import java.util.function.Function;

class ReflectionManChangeLogGenerator extends MapManChangeLogGenerator {
    @Override
    protected Map<String, Function<Man, Object>> createMap() {
        Field[] fields = Man.class.getDeclaredFields();
        HashMap<String, Function<Man, Object>> map = new HashMap<>(fields.length);
        for (Field field : fields) {
            String fieldName = field.getName();
            String capitalizedFieldName = getCapitalized(fieldName);
            for (Method method : Man.class.getDeclaredMethods()) {
                String methodName = method.getName();
                if (isGetter(methodName, capitalizedFieldName)) {
                    map.put(fieldName, createGetter(method));
                    break;
                }
            }
        }
        return map;
    }

    private String getCapitalized(String name) {
        return name.substring(0, 1).toUpperCase()   name.substring(1);
    }

    private boolean isGetter(String methodName, String lastMethodNamePart) {
        return (methodName.startsWith("get") && methodName.equals("get"   lastMethodNamePart))
                || (methodName.startsWith("is") && methodName.equals("is"   lastMethodNamePart));
    }

    private Function<Man, Object> createGetter(Method method) {
        return instance -> {
            try {
                return method.invoke(instance);
            } catch (IllegalAccessException | InvocationTargetException e) {
                throw new IllegalArgumentException(instance.toString(), e);
            }
        };
    }
}

import dev.alexengrig.metter.annotation.GetterSupplier;

@GetterSupplier
class Man {/*...*/}

import java.util.Map;
import java.util.function.Function;

class GenerationManChangeLogGenerator extends MapManChangeLogGenerator {
    @Override
    protected Map<String, Function<Man, Object>> createMap() {
        return new ManGetterSupplier().get();
    }
}