Class Mappers

CodenameOne/src/com/codename1/mapping/Mappers.java:71–277

/// are never persisted, so the renaming has no observable effect on
/// behavior.
public final class Mappers {

    private static final Map<String, Mapper<?>> BY_NAME = new HashMap<String, Mapper<?>>();

    private Mappers() {
    }

    /// Installs `mapper` under `mapper.type().getName()`. The generated
    /// per-class mapper's static initializer calls this; hand-written
    /// mappers for classes outside the build's annotation scan call it
    /// explicitly.
    public static <T> void register(Mapper<T> mapper) {
        if (mapper == null) {
            throw new IllegalArgumentException("mapper is null");
        }
        BY_NAME.put(mapper.type().getName(), mapper);
    }

    /// Looks up the mapper for `type` (by `type.getName()`) or null when
    /// none is registered.
    @SuppressWarnings("unchecked")
    public static <T> Mapper<T> get(Class<T> type) {
        if (type == null) {
            return null;
        }
        return (Mapper<T>) BY_NAME.get(type.getName());
    }

    /// Serializes `instance` to JSON. Throws `IllegalStateException` when
    /// no mapper is registered for its concrete class; that always points
    /// at a missing `@Mapped` annotation or a build that ran without the
    /// process-annotations Mojo.
    public static String toJson(Object instance) {
        if (instance == null) {
            return "null";
        }
        @SuppressWarnings("unchecked")
        Mapper<Object> m = (Mapper<Object>) BY_NAME.get(instance.getClass().getName());
        if (m == null) {
            throw missing(instance.getClass());
        }
        Map<String, Object> root = m.toMap(instance);
        StringBuilder sb = new StringBuilder();
        writeJson(sb, root);
        return sb.toString();
    }

    /// Inverse of `#toJson`. Parses the JSON text and hands the resulting
    /// Map to the registered mapper.
    public static <T> T fromJson(String json, Class<T> type) {
        if (json == null) {
            return null;
        }
        Mapper<T> m = get(type);
        if (m == null) {
            throw missing(type);
        }
        try {