All Downloads are FREE. Search and download functionalities are using the official Maven repository.

net.hamnaberg.json.codec.reflection.ReflectionCodec Maven / Gradle / Ivy

Go to download

The newest version!
package net.hamnaberg.json.codec.reflection;

import net.hamnaberg.json.codec.Codecs;
import net.hamnaberg.json.codec.DecodeResult;
import net.hamnaberg.json.Json;
import net.hamnaberg.json.codec.JsonCodec;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.math.BigInteger;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public final class ReflectionCodec implements JsonCodec {
    private final Class type;
    private final Map> codecs;
    private final List fields;
    private final Factory factory;

    private static Map, JsonCodec> defaultCodecs;

    static {
        Map, JsonCodec> codecs = new HashMap<>();
        codecs.put(String.class, Codecs.CString);
        codecs.put(Integer.class, Codecs.CInt);
        codecs.put(int.class, Codecs.CInt);
        codecs.put(double.class, Codecs.CDouble);
        codecs.put(long.class, Codecs.CLong);
        codecs.put(Long.class, Codecs.CLong);
        codecs.put(Double.class, Codecs.CDouble);
        codecs.put(BigInteger.class, Codecs.CNumber);
        codecs.put(Number.class, Codecs.CNumber);
        codecs.put(Boolean.class, Codecs.CBoolean);
        defaultCodecs = Collections.unmodifiableMap(codecs);
    }

    public ReflectionCodec(Class type) {
        this(type, Collections.emptyMap());
    }

    public ReflectionCodec(Class type, Map> codecs) {
        this(type, codecs, (p) -> true, Optional.empty());
    }

    public ReflectionCodec(Class type, Map> codecs, Predicate predicate) {
        this(type, codecs, predicate, Optional.empty());
    }

    public ReflectionCodec(Class type, Map> codecs, Predicate predicate, Optional factoryMethod) {
        this.type = type;
        this.codecs = codecs;
        this.fields = getFields(type).stream().filter(predicate).collect(Collectors.toUnmodifiableList());
        this.factory = factoryMethod.map(n -> Factory.factory(type, n, fields)).orElse(Factory.constructor(type, fields));
    }

    @Override
    public Json.JValue toJson(A value) {
        Map map = new LinkedHashMap<>();
        for (Param field : fields) {
            Optional> codec = getCodec(field);
            Optional optValue = field.get(value);
            Optional opt = optValue.flatMap(o -> codec.map(c -> c.toJson(o)));
            opt.ifPresent(v -> map.put(field.getName(), v));
        }
        return map.isEmpty() ? Json.jNull() : Json.jObject(map);
    }

    @Override
    public DecodeResult fromJson(Json.JValue value) {
        Json.JObject object = value.asJsonObjectOrEmpty();
        ArrayList arguments = new ArrayList<>();

        for (Param field : fields) {
            JsonCodec codec = getCodec(field).orElseThrow(() -> {
                throw new NoSuchElementException("Missing codec for " + field.getName());
            });
            DecodeResult result = DecodeResult.decode(object, field.getName(), codec);
            result.forEach(arguments::add);
        }

        try {
            return DecodeResult.ok(this.factory.invoke(List.copyOf(arguments)));
        } catch (Exception e) {
            return DecodeResult.fail(e.getMessage());
        }
    }

    @SuppressWarnings("unchecked")
    private Optional> getCodec(Param field) {
        return Optional.ofNullable(
                (JsonCodec) codecs.getOrDefault(field.getName(), defaultCodecs.get(field.getType()))
        );
    }


    @Override
    public String toString() {
        return String.format("ReflectionCodec(%s)", type.getName());
    }

    private static String getterOf(String field) {
        return "get" + Character.toUpperCase(field.charAt(0)) + field.substring(1);
    }

    private static  List getFields(Class type) {
        Field[] declared = type.getDeclaredFields();
        ArrayList fields = new ArrayList<>(declared.length);
        for (Field field : declared) {
            int modifiers = field.getModifiers();
            if (Modifier.isFinal(modifiers) && Modifier.isPublic(modifiers)) {
                fields.add(new FieldParam(field.getName(), field));
            }
        }
        if (fields.isEmpty()) {
            for (Field field : declared) {
                try {
                    Method method = type.getDeclaredMethod(getterOf(field.getName()));
                    if (method != null) {
                        fields.add(new MethodParam(field.getName(), method));
                    }
                } catch (NoSuchMethodException ignore) {
                }
            }
        }
        return List.copyOf(fields);
    }
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy