Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.json;

import com.jayway.jsonpath.JsonPath;

import java.io.ByteArrayInputStream;

import java.io.StringWriter;

import java.math.BigDecimal;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Objects;

import javax.json.JsonArray;

import javax.json.JsonNumber;

import javax.json.JsonObject;

import javax.json.JsonReader;

import javax.json.JsonString;

import javax.json.JsonStructure;

import javax.json.JsonValue;

import javax.json.JsonWriter;

import javax.json.JsonWriterFactory;

import javax.json.stream.JsonGenerator;

import static org.gvsig.json.JsonManager.ATTRIBUTE_NAME_CLASS;

import org.gvsig.json.serializers.DataTypeSerializer;

import org.gvsig.json.serializers.DefaultObjectSerializer;

import org.gvsig.json.serializers.DynObjectSerializer;

import org.gvsig.json.serializers.DynObjectValueItemSerializer;

import org.gvsig.json.serializers.FileSerializer;

import org.gvsig.json.serializers.LocaleSerializer;

import org.gvsig.json.serializers.TagsSerializer;

import org.gvsig.json.serializers.UriSerializer;

import org.gvsig.json.serializers.UrlSerializer;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.util.GetItemWithSizeAndIterator;

import org.gvsig.tools.util.IsApplicable;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class JsonManagerImpl implements JsonManager {

    private final Map<String,JsonSerializer> serializers1;

    private final Map<String,IsApplicable> serializers2;

    private final DynObjectSerializer dynObjectSerializer;

    public JsonManagerImpl() {

        this.dynObjectSerializer = new DynObjectSerializer();

        this.serializers1 = new HashMap<>();

        this.serializers2 = new HashMap<>();

        this.registerSerializer(new FileSerializer());

        this.registerSerializer(new UrlSerializer());

        this.registerSerializer(new UriSerializer());

        this.registerSerializer(new LocaleSerializer());

        this.registerSerializer(new TagsSerializer());

        this.registerSerializer(new DynObjectValueItemSerializer());

        this.registerSerializer(new DataTypeSerializer());

//        this.registerSerializer(this.dynObjectSerializer);

    }

    @Override

    public void registerSerializer(Class<?extends SupportFromJson> theClass) {

        if (theClass == null) {

            return;

        }

        if (!SupportFromJson.class.isAssignableFrom(theClass)) {

            throw new IllegalArgumentException("the class '" + theClass.getName() + "'must implement SupportFromJson");

        }

        this.serializers1.put(theClass.getName(), new DefaultObjectSerializer(theClass));

    }

    @Override

    public void registerSerializer(JsonSerializer serializer) {

        this.serializers1.put(serializer.getObjectClass().getName(), serializer);

        if( serializer instanceof IsApplicable ) {

            this.serializers2.put(serializer.getObjectClass().getName(), (IsApplicable) serializer);

        }

    }

    @Override

    public JsonSerializer getSerializer(Object value) {

        JsonSerializer serializer1 = this.serializers1.get(value.getClass().getName());

        if( serializer1!=null ) {

            return serializer1;

        }

        for (IsApplicable serializer2 : this.serializers2.values()) {

            if( serializer2.isApplicable(value) ) {

                return (JsonSerializer) serializer2;

            }

        }

        if( value instanceof DynObject ) {

            return this.dynObjectSerializer;

        }

        return null;

    }

    @Override

    public JsonSerializer getSerializer(JsonObject json) {

        String className = json.getString(ATTRIBUTE_NAME_CLASS, null);

        JsonSerializer serializer1 = this.serializers1.get(className);

        if( serializer1!=null ) {

            return serializer1;

        }

        for (IsApplicable serializer2 : this.serializers2.values()) {

            if( serializer2.isApplicable(json) ) {

                return (JsonSerializer) serializer2;

            }

        }

        if( this.dynObjectSerializer.isApplicable(json) ) {

            return this.dynObjectSerializer;

        }

        return null;

    }

    @Override

    public JsonObjectBuilder createObjectBuilder() {

        return new JsonObjectBuilderImpl();

    }

    @Override

    public JsonArrayBuilder createArrayBuilder() {

        return new JsonArrayBuilderImpl();

    }

    @Override

    public JsonObject createObject(String json) {

        try {

            ByteArrayInputStream data = new ByteArrayInputStream(json.getBytes());

            JsonReader reader = javax.json.Json.createReader(data);

            JsonObject x = reader.readObject();

            return new org.gvsig.json.JsonObjectImpl(x);

        } catch (Exception ex) {

            return null;

        }

    }

    @Override

    public JsonArray createArray(String json) {

        try {

            ByteArrayInputStream data = new ByteArrayInputStream(json.getBytes());

            JsonReader reader = javax.json.Json.createReader(data);

            JsonArray x = reader.readArray();

            return new org.gvsig.json.JsonArrayImpl(x);

        } catch (Exception ex) {

            return null;

        }

    }

    private String toString(JsonStructure obj) {

        StringWriter sw = new StringWriter();

        JsonWriterFactory writerFactory = javax.json.Json.createWriterFactory(

                Collections.singletonMap(JsonGenerator.PRETTY_PRINTING, true)

        );

        try (JsonWriter jsonWriter = writerFactory.createWriter(sw)) {

            jsonWriter.write(obj);

        }

        String s = sw.toString();

        return s;

    }

    @Override

    public String toString(JsonValue value) {

        if( value == null ) {

            return Objects.toString(null);

        }

        switch (value.getValueType()) {

            case ARRAY:

            case OBJECT:

                return this.toString((JsonStructure)value);

            case FALSE:

            case NUMBER:

            case STRING:

            case TRUE:

            case NULL:

            default:

                return value.toString();

        }

    }

    @Override

    public Object toObject(JsonObject json, String name) {

        JsonValue value = json.get(name);

        return toObject(value);

    }

    @Override

    public Object toObject(JsonArray json, int index) {

        JsonValue value = json.get(index);

        return toObject(value);

    }

    private Object createObject(JsonObject json, Object defaultValue) {

        if (json == null) {

            return defaultValue;

        }

        JsonSerializer serializer = this.getSerializer(json);

        if (serializer == null) {

            return defaultValue;

        }

        Object obj = serializer.toObject(json);

        if (obj == null) {

            return defaultValue;

        }

        return obj;

    }

    @Override

    public Iterable<Object> toIterable(final JsonArray jsonArray) {

        @SuppressWarnings("Convert2Lambda")

        Iterable<Object> iterable = new Iterable<Object>() {

            @Override

            public Iterator<Object> iterator() {

                Iterator<Object> it = new Iterator<Object>() {

                    int current= 0;

                    @Override

                    public boolean hasNext() {

                        return current<jsonArray.size();

                    }

                    @Override

                    public Object next() {

                        return toObject(jsonArray.get(current++));

                    }

                };

                return it;

            }

        };

        return iterable;

    }

    @Override

    public GetItemWithSizeAndIterator<Object> toItems(final JsonArray jsonArray) {

        GetItemWithSizeAndIterator<Object> items = new GetItemWithSizeAndIterator<Object>() {

            @Override

            public int size() {

                return jsonArray.size();

            }

            @Override

            public Object get(int position) {

                return toObject(jsonArray.get(position));

            }

            @Override

            public Iterator<Object> iterator() {

                Iterator<Object> it = new Iterator<Object>() {

                    int current= 0;

                    @Override

                    public boolean hasNext() {

                        return current<jsonArray.size();

                    }

                    @Override

                    public Object next() {

                        return toObject(jsonArray.get(current++));

                    }

                };

                return it;

            };

        };

        return items;

    }

    @Override

    public Object[] toArray(JsonArray jsonArray, Object[] a) {

        if( jsonArray==null ) {

            return null;

        }

        int sz = jsonArray.size();

        if( a==null ) {

            a = new Object[sz];

        } else if (a.length != sz) {

            a = Arrays.copyOf(a, sz);

        }

        for (int i = 0; i < sz; i++) {

            JsonValue value = jsonArray.get(i);

            a[i] = this.toObject(value);

        }

        return a;

    }

    @Override

    public Object toObject(JsonValue value) {

        return this.toObjectOrDefault(value, null);

    }

    @Override

    public Object toObjectOrDefault(JsonValue value, Object defaultValue) {

        if( value == null ) {

            return defaultValue;

        }

        switch (value.getValueType()) {

            case ARRAY:

                return this.toArray((JsonArray) value, new Object[0]);

            case FALSE:

                return false;

            case NUMBER:

                JsonNumber n = (JsonNumber) value;

                if (n.isIntegral()) {

                    int nint = n.intValue();

                    long nlong = n.longValue();

                    if (nint == nlong) {

                        return nint;

                    }

                    if (n.bigDecimalValue().compareTo(new BigDecimal(nlong)) == 0) {

                        return nlong;

                    }

                    return n.bigIntegerValue();

                } else {

                    double ndouble = n.doubleValue();

                    if (n.bigDecimalValue().compareTo(new BigDecimal(ndouble)) == 0) {

                        return ndouble;

                    }

                    return n.bigDecimalValue();

                }

            case OBJECT:

                return this.createObject((JsonObject) value, defaultValue);

            case STRING:

                return ((JsonString) value).getString();

            case TRUE:

                return true;

            case NULL:

                return null;

            default:

                return defaultValue;

        }

    }

    @Override

    public DynObject addAll(DynObject target, JsonObject json) {

        if( json == null || target==null ) {

            return target;

        }

        DynClass dynClass = target.getDynClass();

        String name = null;

        try {

            for (DynField dynField : dynClass.getDynFields()) {

                name = dynField.getName();

                if( json.containsKey(name) ) {

                    target.setDynValue(name, this.toObject(json.get(name)));

                }

            }            

        } catch (Exception ex) {

            throw new RuntimeException("Can't copy values from json to DynObject (class "+dynClass.getFullName()+", field "+name+").", ex);

        }

        return target;

    }

    @Override

    public Map toMap(JsonObject json) {

        if( json == null ) {

            return null;

        }

        Map map = new HashMap();

        for (String name : json.keySet()) {

            map.put(name, this.toObject(json.get(name)));

        }

        return map;

    }

    public static JsonValue wrap(JsonValue value) {

        if( value == null ) {

            return null;

        } else if( value == JsonValue.NULL ) {

            return null;

        } else if( value instanceof JsonObject &&

                !(value instanceof org.gvsig.json.JsonObjectImpl)) {

            value = new org.gvsig.json.JsonObjectImpl((JsonObject) value);

        } else if( value instanceof JsonArray &&

                !(value instanceof org.gvsig.json.JsonArrayImpl)) {

            value = new org.gvsig.json.JsonArrayImpl((JsonArray) value);

        }

        return value;

    }

    @Override

    public JsonObjectBuilder createObjectBuilder(String json) {

        JsonObject obj = this.createObject(json);

        return this.createObjectBuilder(obj);

    }

    @Override

    public JsonObjectBuilder createObjectBuilder(JsonObject obj) {

        JsonObjectBuilder builder = this.createObjectBuilder();

        for (Map.Entry<String, JsonValue> entry : obj.entrySet()) {

            builder.add(entry.getKey(), entry.getValue());

        }

        return builder;

    }

    @Override

    public JsonPathContext createJSonPathContext(JsonStructure jsonObject) {

        return new JsonPathContextImpl(this, jsonObject);

    }

    @Override

    public JsonPathContext createJSonPathContext(String jsonObject) {

        return new JsonPathContextImpl(this, jsonObject);

    }

}