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

====

    gvSIG. Desktop Geographic Information System.

    Copyright (C) 2007-2013 gvSIG Association.

    This program is free software; you can redistribute it and/or

    modify it under the terms of the GNU General Public License

    as published by the Free Software Foundation; either version 2

    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

    MA  02110-1301, USA.

    For any additional information, do not hesitate to contact us

    at info AT gvsig.com, or visit our website www.gvsig.com.

====

The first time you checkout the current project to a new workspace, 

you have to prepare it to be able to work easily with maven from

eclipse itself.

Perform the following steps:

1.- Launch the *prepare-workspace.xml* ant build file. 

    You can do it by loading the file into the ant view, 

    and running the default task, or right-clicking the 

    file from the package explorer or the navigator and

    select the option: *Run as > Ant build*. 

2.- Restart eclipse.

3.- Import the subprojects of the project you have just checked out.

Those steps are only needed once per workspace.     

org.gvsig.tools.util.impl.ToolsUtilLibraryImpl

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.euclidean;

import java.awt.geom.Point2D;

/**

 *

 * @author fdiaz

 */

public class DefaultEuclideanManager implements EuclideanManager{

    @Override

    public EuclideanLine2D createLine2D(double coefA, double coefB, double coefC) {

        return new EuclideanLine2DImpl(coefA, coefB, coefC);

    }

    @Override

    public EuclideanLine2D createLine2D(double m, double b) {

        return new EuclideanLine2DImpl(m, b);

    }

    @Override

    public EuclideanLine2D createLine2D(double x0, double y0, double x1, double y1) {

        return new EuclideanLine2DImpl(x0, y0, x1, y1);

    }

    @Override

    public EuclideanLine2D createLine2D(Point2D p1, Point2D p2) {

        return new EuclideanLine2DImpl(p2, p1);

    }

    @Override

    public EuclideanLine2D createLine2D(double m, Point2D p) {

        if(Double.isInfinite(m)){

            return new EuclideanLine2DImpl(1, 0, -p.getX());

        }

        return new EuclideanLine2DImpl(m, getYIntercept(m, p));

    }

    @Override

    public double getYIntercept(double m, Point2D p) {

        return getYIntercept(m, p.getX(), p.getY());

    }

    @Override

    public double getYIntercept(double m, double x, double y) {

        return -m*x+y;

    }

    @Override

    public double distance(Point2D p1, Point2D p2) {

        double x = Math.sqrt( Math.pow(p2.getX()-p1.getX(), 2)+Math.pow(p2.getY()-p1.getY(), 2));

        return x;

    }

    @Override

    public double distance(double x1, double y1, double x2, double y2) {

        double x = Math.sqrt( Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2));

        return x;

    }

    @Override

    public Point2D getCenter(double ax, double ay, double bx, double by, double cx, double cy) {

        Point2D midPointAC = getMidPoint(ax, ay, cx, cy);

        EuclideanLine2D lineAC = createLine2D(ax, ay, cx, cy);

        EuclideanLine2D bisectorAC = lineAC.getPerpendicular(midPointAC.getX(), midPointAC.getY());

        Point2D midPointBC = getMidPoint(bx, by, cx, cy);

        EuclideanLine2D lineBC = createLine2D(bx, by, cx, cy);

        EuclideanLine2D bisectorBC = lineBC.getPerpendicular(midPointBC.getX(), midPointBC.getY());

        Point2D intersection = bisectorAC.getIntersection(bisectorBC);

        return new Point2D.Double(intersection.getX(), intersection.getY());

    }

    @Override

    public Point2D getCenter(Point2D a, Point2D b, Point2D c) {

        return this.getCenter(a.getX(), a.getY(), b.getX(), b.getY(), c.getX(), c.getY());

    }

    @Override

    public Point2D getMidPoint(Point2D a, Point2D b) {

        return getMidPoint(a.getX(), a.getY(), b.getX(), b.getY());

    }

    @Override

    public Point2D getMidPoint(double ax, double ay, double bx, double by) {

        double x = (ax + bx) / 2;

        double y = (ay + by) / 2;

        return new Point2D.Double(x, y);

    }

    @Override

    public double getCoefDirection(double centerx, double centery, double point1x, double point1y, double point2x, double point2y) {

        return Math.signum((point1x - centerx) * (point2y - centery) - (point1y - centery) * (point2x - centerx));

    }

    @Override

    public double getCoefDirection(Point2D center, Point2D point1, Point2D point2) {

        return this.getCoefDirection(center.getX(), center.getY(), point1.getX(), point1.getY(), point2.getX(), point2.getY());

    }

    @Override

    public double calculateAngle(double vertexx, double vertexy, double p1x, double p1y, double p2x, double p2y){

        double angle = Math.atan2(

                p2y - vertexy, 

                p2x - vertexx

        ) - Math.atan2(

                p1y - vertexy, 

                p1x - vertexx

        ); 

        if (angle<0){

            return 2*Math.PI+angle;

        }

        return angle;

    }

    @Override

    public double calculateAngle(double vertexx, double vertexy, double px, double py){

        double angle = Math.atan2(

                py - vertexy, 

                px - vertexx

        ) - Math.atan2(

                0, 

                1

        ); 

        if (angle<0){

            return 2*Math.PI+angle;

        }

        return angle;

    }

    @Override

    public boolean areThreePointsInLine(double ax, double ay, double bx, double by, double cx, double cy){

        if( (ax==bx && ay==by) || (ax==cx && ay==cy) || (bx==cx && by==cy) ) {

            return true;

        }

        return Math.abs((bx-ax)/(cx-bx)-(by-ay)/(cy-by)) < 2 * Double.MIN_VALUE;

    }

    @Override

    public Point2D getPointAtDistance(double x1, double y1, double distance, double angle, String unit) {

        if ( "s".equals(unit) ){

            angle = Math.toRadians(angle);

        } else if ( "g".equals(unit) ) {

            angle = Math.PI * angle / 200;

        }

        double deltaX = distance * Math.cos(angle);

        double deltaY = distance * Math.sin(angle);

        Point2D r = new Point2D.Double(x1+deltaX, y1+deltaY);

        return r;

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.euclidean;

import java.awt.geom.Point2D;

/**

 *

 * @author fdiaz

 */

public class EuclideanLine2DImpl implements EuclideanLine2D {

    double coefA;

    double coefB;

    double coefC;

    double m;

    double b;

    public EuclideanLine2DImpl(double coefA, double coefB, double coefC) {

        this.coefA = coefA;

        this.coefB = coefB;

        this.coefC = coefC;

        reduceCoefs();

        this.m = -coefA/coefB;

        if(this.m == -0.0){

            this.m = 0.0;

        }

        this.b = -coefC / coefB;

    }

    /**

     * If m parameter m is infinite, preferably use the constructor EuclideanLine2DImpl(double coefA, double coefB, double coefC)

     * 

     * @param m

     * @param b 

     */

    public EuclideanLine2DImpl(double m, double b) {

        this.m = m;

        this.b = b;

        this.coefA = m;

        this.coefB = -1.0;

        this.coefC = b;

        reduceCoefs();

    }

    public EuclideanLine2DImpl(double x0, double y0, double x1, double y1) {

        this(y1 - y0, -(x1 - x0), -(y1 - y0) * x0 + (x1 - x0) * y0);

    }

    public EuclideanLine2DImpl(Point2D p0, Point2D p1) {

        this(p0.getX(), p0.getY(), p1.getX(), p1.getY());

    }

    private void reduceCoefs() {

        if(coefA != 0 && Double.isFinite(coefA)){

            coefC = coefC/coefA;

            coefB = coefB/coefA;

            coefA = 1.0;

        } else if(coefB != 0 && Double.isFinite(coefB)){

            coefA = coefA/coefB; // for change the sign of coefA when coefA is infinite && coefB = -1;

            coefC = coefC/coefB;

            coefB = 1.0;

        }

    }

    @Override

    public double getA() {

        return coefA;

    }

    @Override

    public double getB() {

        return coefB;

    }

    @Override

    public double getC() {

        return coefC;

    }

    @Override

    public double getSlope() {

        return m;

    }

    @Override

    public double getYIntercept() {

        return b;

    }

    @Override

    public double getY(double x) {

        return (-coefA*x-coefC)/coefB;

    }

    @Override

    public double getX(double y) {

        return (-coefB*y-coefC)/coefA;

    }

    @Override

    public double getAngle() {

        return Math.atan(m);

    }

    @Override

    public double getDegreesAngle() {

        return Math.toDegrees(getAngle());

    }

    @Override

    public double getAngle(EuclideanLine2D line) {

        double m1 = line.getSlope();

        return Math.atan(Math.abs((m1-m)/(1+m1*m)));

    }

    @Override

    public double getAngle(EuclideanLine2D line, Point2D quadrant) {

        EuclideanLine2D[] bisectors = this.getBisectors(line);

        if(bisectors[0].getDistance(quadrant)<=bisectors[1].getDistance(quadrant)){

            return 2*this.getAngle(bisectors[0]);

        } else {

            return 2*this.getAngle(bisectors[1]);

        }

    }

    @Override

    public double getDegreesAngle(EuclideanLine2D line) {

        return Math.toDegrees(getAngle(line));

    }

    @Override

    public double getDegreesAngle(EuclideanLine2D line, Point2D quadrant) {

        return Math.toDegrees(getAngle(line, quadrant));

    }

    @Override

    public double getDistance(double pointX, double pointY) {

        // d(P,r)=|A*px+B*py+C|/SQRT(A?+B?)

        double den = Math.abs(Math.sqrt(Math.pow(coefA, 2) + Math.pow(coefB, 2)));

        return Math.abs((coefA * pointX + coefB * pointY + coefC)) / den;

    }

    @Override

    public double getDistance(Point2D point) {

        return getDistance(point.getX(), point.getY());

    }

    @Override

    public double getDistance(EuclideanLine2D line) {

        if (isParallel(line)) { //Parallel lines

            Double num = Math.abs(line.getC() - coefC);

            if (Double.isInfinite(m)) { //Vertical lines

                return num;

            }

            Double den = Math.sqrt(Math.pow(coefA, 2) + Math.pow(coefB, 2));

            return num / den;

        }

        return 0d;

    }

    @Override

    public boolean isParallel(EuclideanLine2D line) {

        double m1 = line.getSlope();

        return (m == m1 || (Double.isInfinite(m) && Double.isInfinite(m1)));

    }

    @Override

    public boolean isPerpendicularl(EuclideanLine2D line) {

        double m1 = line.getSlope();

        return (m * m1 == -1 || (Double.isInfinite(m) && m1 == 0.0) || (m==0 && Double.isInfinite(m1)));

//        return (getA()*line.getA()+getB()*line.getB() == 0);

    }

    @Override

    public Point2D getIntersection(EuclideanLine2D line) {

        //Using Cramer's rule

        double a1 = coefA;

        double b1 = coefB;

        double c1 = coefC;

        Double a2 = line.getA();

        Double b2 = line.getB();

        Double c2 = line.getC();

        Double det = a1 * b2 - a2 * b1;

        Double detX = -c1 * b2 + c2 * b1;

        Double detY =  -a1 * c2 + a2 * c1;

        Double x = detX / det;

        Double y = detY / det;

        return new Point2D.Double(x, y);

        //Using Apache commons math library, need import the library

//        RealMatrix coefficients =

//        new Array2DRowRealMatrix(new double[][] { { coefA, coefB }, { line.getA(), line.getB() } }, false);

//        DecompositionSolver solver = new LUDecomposition(coefficients).getSolver();

//        RealVector constants = new ArrayRealVector(new double[] { -coefC, -line.getC() }, false);

//        RealVector solution = solver.solve(constants);

//        return new Point2D.Double(solution.getEntry(0), solution.getEntry(1));

    }

    @Override

    public EuclideanLine2D getPerpendicular(double pointX, double pointY) {

        if(Math.abs(m)==0.0){

            return new EuclideanLine2DImpl(1, 0, -pointX);

        }

        if(Double.isInfinite(m)){

            return new EuclideanLine2DImpl(0, 1, -pointY);

        }

        // perpendicular slope (m)

        Double m1 = -1 / m;

        // perpendicular y-intercept (b)

        Double b1 = pointY - (m1 * pointX);

        return new EuclideanLine2DImpl(m1, b1);

    }

    @Override

    public EuclideanLine2D getPerpendicular(Point2D point) {

        return getPerpendicular(point.getX(), point.getY());

    }

        @Override

    public EuclideanLine2D getParallel(double pointX, double pointY) {

        if(Math.abs(m)==0.0){

            return new EuclideanLine2DImpl(0, 1, -pointY);

        }

        if(Double.isInfinite(m)){

            return new EuclideanLine2DImpl(1, 0, -pointX);

        }

        // parallel slope (m)

        Double m1 = m;

        // parallel y-intercept (b)

        Double b1 = pointY - (m1 * pointX);

        return new EuclideanLine2DImpl(m1, b1);

    }

    @Override

    public EuclideanLine2D getParallel(Point2D point) {

        return getParallel(point.getX(), point.getY());

    }

    @Override

    public Point2D getNearestPoint(double pointX, double pointY) {

        double x;

        double y;

        if (Double.isInfinite(m)) {

            y = pointY;

            x = (-coefB * y - coefC) / coefA;

        } else if (Math.abs(m) == 0) {

            x = pointX;

            y = b;

        } else {

            EuclideanLine2D perp = getPerpendicular(pointX, pointY);

            Double m1 = perp.getSlope();

            Double b1 = perp.getYIntercept();

            x = (b1 - b) / (m - m1);

            y = m * x + b;

        }

        return new Point2D.Double(x, y);

    }

    @Override

    public Point2D getNearestPoint(Point2D point) {

        return getNearestPoint(point.getX(), point.getY());

    }

    @Override

    public EuclideanLine2D[] getBisectors(EuclideanLine2D line) {

        /*

            r) A1x + B1y + C1 = 0

            s) A2x + B2y + C2 = 0

            |A1x+B1y+C1|/SQRT(A1?+B1?)= |A2x+B2y+C2|/SQRT(A2?+B2?)

        */

        Double a1 = coefA;

        Double b1 = coefB;

        Double c1 = coefC;

        Double a2 = line.getA();

        Double b2 = line.getB();

        Double c2 = line.getC();

        Double den1 = Math.sqrt(Math.pow(a1,2) + Math.pow(b1,2));

        Double den2 = Math.sqrt(Math.pow(a2,2) + Math.pow(b2,2));

        EuclideanLine2D[] result = new EuclideanLine2DImpl[2];

        result[0] = new EuclideanLine2DImpl(

                den2 * a1 - den1 * a2,

                den2 * b1 - den1 * b2,

                den2 * c1 - den1 * c2

        );

        result[1] = new EuclideanLine2DImpl(

                den2 * a1 + den1 * a2,

                den2 * b1 + den1 * b2,

                den2 * c1 + den1 * c2

        );

        return result;

    }

    @Override

    public Point2D getSymmetricalPoint(Point2D point) {

        Point2D nearestPoint = getNearestPoint(point);

        Point2D.Double symmetricalPoint = new Point2D.Double(

                2*nearestPoint.getX()-point.getX(), 

                2*nearestPoint.getY()-point.getY()

        );

        return symmetricalPoint;

    }

}

package org.gvsig.json;

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 org.apache.commons.codec.digest.DigestUtils;

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.registerDefaultSerializers();

    }

    private void registerDefaultSerializers() {

        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);

    }

    public static String createSerializerKey(Class aClass) {

        String key = aClass.getName();

//        String key = "0-" + DigestUtils.sha256Hex(aClass.getName());

        return key;

    }

    public static String createSerializerKey(String className) {

        String key = className;

//        String key = "0-"+ DigestUtils.sha256Hex(className);

        return key;

    }

    @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");

        }

        String key = createSerializerKey(theClass);

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

    }

    @Override

    public void registerSerializer(JsonSerializer serializer) {

        String key = createSerializerKey(serializer.getObjectClass());

        this.serializers1.put(key, serializer);

        if( serializer instanceof IsApplicable ) {

            this.serializers2.put(key, (IsApplicable) serializer);

        }

    }

    @Override

    public JsonSerializer getSerializer(Object value) {

        String key = createSerializerKey(value.getClass());

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

        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);

        String key = createSerializerKey(className);

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

        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);

    }

}

package org.gvsig.json;

import java.io.StringWriter;

import java.math.BigDecimal;

import java.math.BigInteger;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.json.JsonObject;

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.JsonManager.JsonSerializer;

import static org.gvsig.json.JsonManagerImpl.createSerializerKey;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.util.GetItemByKeyWithGetKeys;

import org.gvsig.tools.util.GetItemWithSize;

/**

 *

 * @author gvSIG Team

 */

public class JsonObjectBuilderImpl implements JsonObjectBuilder {

    private final javax.json.JsonObjectBuilder builder;

    private final JsonManager manager;

    public JsonObjectBuilderImpl() {

        this(Json.getManager());

    }

    public JsonObjectBuilderImpl(JsonManager manager) {

        this.manager = manager;

        this.builder = javax.json.Json.createObjectBuilder();

    }

    @Override

    public JsonObjectBuilder add(String name, SupportToJson value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        this.builder.add(name, value.toJsonBuilder());

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, Object value) {

        if (value == null) {

            this.builder.addNull(name);

        } else if (value instanceof SupportToJson) {

            this.add(name, ((SupportToJson)value).toJsonBuilder());

        } else if (value instanceof String) {

            this.builder.add(name, (String) value);

        } else if (value instanceof Integer) {

            this.builder.add(name, (int) value);

        } else if (value instanceof Long) {

            this.builder.add(name, (long) value);

        } else if (value instanceof BigInteger) {

            this.builder.add(name, (BigInteger) value);

        } else if (value instanceof BigDecimal) {

            this.builder.add(name, (BigDecimal) value);

        } else if (value instanceof Double) {

            this.builder.add(name, (double) value);

        } else if (value instanceof Boolean) {

            this.builder.add(name, (boolean) value);

        } else if (value.getClass().isArray()) {

            this.add(name, (Object[]) value);

        } else if (value instanceof Class) {

            this.add(name, (Class) value);

        } else {

            JsonSerializer serializer = manager.getSerializer(value);

            if( serializer!=null ) {

                this.add(name, serializer.toJsonBuilder(value));

            } else if (value instanceof DynObject) {

                this.add(name, (DynObject) value);

            } else if (value instanceof GetItemByKeyWithGetKeys) {

                this.add(name, (GetItemByKeyWithGetKeys<Object,Object>) value);

            } else if (value instanceof List) {

                this.add(name, (List<Object>) value);

            } else if (value instanceof Set) {

                this.add(name, (Set<Object>) value);

            } else if (value instanceof Map) {

                this.add(name, (Map<String,Object>) value);

            } else if (value instanceof Iterable) {

                this.add(name, (Iterable<Object>) value);

            } else if (value instanceof Iterator) {

                this.add(name, (Iterator<Object>) value);

            } else {

                throw new IllegalArgumentException("Can't serialize to Json an object of class '"+value.getClass().getName()+"'.");

            }

        }

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, Object[] value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonArrayBuilder arrayBuilder = new JsonArrayBuilderImpl();

        arrayBuilder.addAll(value);

        this.builder.add(name, arrayBuilder);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, Iterable value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonSerializer serializer = this.manager.getSerializer(value);

        if( serializer!=null ) {

            this.builder.add(name, serializer.toJsonBuilder(value));

        } else {

            JsonArrayBuilder arrayBuilder = new JsonArrayBuilderImpl();

            arrayBuilder.addAll(value);

            this.builder.add(name, arrayBuilder);

        }

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, Map value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonObjectBuilder objBuilder = new JsonObjectBuilderImpl();

        objBuilder.addAll(value);

        this.builder.add(name, objBuilder);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, GetItemByKeyWithGetKeys value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonSerializer serializer = this.manager.getSerializer(value);

        if( serializer!=null ) {

            this.builder.add(name, serializer.toJsonBuilder(value));

        } else {

            JsonObjectBuilder objBuilder = new JsonObjectBuilderImpl();

            objBuilder.addAll(value);

            this.builder.add(name, objBuilder);

        }

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, GetItemWithSize value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonSerializer serializer = this.manager.getSerializer(value);

        if( serializer!=null ) {

            this.builder.add(name, serializer.toJsonBuilder(value));

        } else {

            JsonArrayBuilder arrayBuilder = new JsonArrayBuilderImpl();

            arrayBuilder.addAll(value);

            this.builder.add(name, arrayBuilder);

        }

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, List value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonSerializer serializer = this.manager.getSerializer(value);

        if( serializer!=null ) {

            this.builder.add(name, serializer.toJsonBuilder(value));

        } else {

            JsonArrayBuilder arrayBuilder = new JsonArrayBuilderImpl();

            arrayBuilder.addAll(value);

            this.builder.add(name, arrayBuilder);

        }

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, Iterator value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonSerializer serializer = this.manager.getSerializer(value);

        if( serializer!=null ) {

            this.builder.add(name, serializer.toJsonBuilder(value));

        } else {

            JsonArrayBuilder arrayBuilder = new JsonArrayBuilderImpl();

            arrayBuilder.addAll(value);

            this.builder.add(name, arrayBuilder);

        }

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, Set value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        JsonSerializer serializer = this.manager.getSerializer(value);

        if( serializer!=null ) {

            this.builder.add(name, serializer.toJsonBuilder(value));

        } else {

            JsonArrayBuilder arrayBuilder = new JsonArrayBuilderImpl();

            arrayBuilder.addAll(value);

            this.builder.add(name, arrayBuilder);

        }

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, javax.json.JsonValue value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, String value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, BigInteger value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, BigDecimal value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, int value) {

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, long value) {

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, double value) {

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, boolean value) {

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, javax.json.JsonObjectBuilder value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add(String name, Class value) {

        if (value == null) {

            this.builder.addNull(name); 

            return this;

        }

        this.builder.add(name, value.getName()); 

        return this;

    }

    @Override

    public javax.json.JsonObjectBuilder add(String name, javax.json.JsonArrayBuilder value) {

        if (value == null) {

            this.builder.addNull(name);

            return this;

        }

        this.builder.add(name, value);

        return this;

    }

    @Override

    public JsonObjectBuilder add_class(Class value) {

        if (value == null) {

            this.builder.addNull(ATTRIBUTE_NAME_CLASS); 

            return this;

        }

        this.builder.add(ATTRIBUTE_NAME_CLASS, createSerializerKey(value)); 

        return this;

    }

    @Override

    public JsonObjectBuilder add_class(Object value) {

        if( value == null ) {

            this.add_class((Class)null);

            return this;

        }

        this.add_class(value.getClass());

        return this;

    }

    @Override

    public JsonObjectBuilder addAll(GetItemByKeyWithGetKeys values) {

        if (values == null) {

            return this;

        }

        for (Object key : values.getKeys()) {

            if( key == null ) {

                continue;

            }

            this.add((String) key, values.get(key));

        }

        return this;

    }

    @Override

    public JsonObjectBuilder addAll(Map values) {

        if (values == null) {

            return this;

        }

        Set<Map.Entry> entries = values.entrySet();

        for (Map.Entry entry : entries) {

            if( entry.getKey()==null ) {

                continue;

            }

            this.add((String) entry.getKey(), entry.getValue());

        }

        return this;

    }

    @Override

    public JsonObjectBuilder addAll(JsonObjectBuilder values) {

        return this.addAll(values.build());

    }

    @Override

    public JsonObjectBuilder addAll(JsonObject values) {

        if (values == null) {

            return this;

        }

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

            if( name==null || name.equals(ATTRIBUTE_NAME_CLASS)) {

                continue;

            }

            this.add(name, values.get(name));

        }

        return this;

    }

    @Override

    public JsonObjectBuilder addAll(DynObject value) {

        DynClass dynClass = value.getDynClass();

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

            String name = dynField.getName();

            this.add(name,value.getDynValue(name));

        }

        return this;

    }

    @Override

    public JsonObjectBuilder addNull(String name) {

        this.builder.addNull(name);

        return this;

    }

    @Override

    public javax.json.JsonObject build() {

        return new JsonObjectImpl(this.builder.build());

    }

    @Override

    public String toString() {

        StringWriter sw = new StringWriter();

        JsonWriterFactory writerFactory = javax.json.Json.createWriterFactory(

                Collections.singletonMap(JsonGenerator.PRETTY_PRINTING, true)

        );

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

            jsonWriter.writeObject(this.builder.build());

        }

        String s = sw.toString();

        return s;

    }

}

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 gvSIG Association.

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License 

 * along with this program. If not, see <https://www.gnu.org/licenses/>. 

 * 

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.json;

import java.io.StringWriter;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import javax.json.JsonArray;

import javax.json.JsonNumber;

import javax.json.JsonObject;

import javax.json.JsonString;