Application: gvSIG desktop

/**

 * 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 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, 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.

 */

package org.gvsig.fmap.geom.jts;

import java.lang.reflect.Constructor;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Objects;

import java.util.Set;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.type.AbstractGeometryType;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.dataTypes.DataType;

/**

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultGeometryType extends AbstractGeometryType {

    /**

     * Geometry type name

     */

    private String name;

    /**

     * Class that implements this class type

     */

    private Class geometryClass;

    /**

     * The type of the geometry. The type is an abstract representation of the

     * object (Point, Curve...) but it is not a concrete representation

     * (Point2D, Point3D...). To do that comparation the id field is used.

     */

    private int type;

    /**

     * The subtype of the geometry. The subtype represents a set of geometries

     * with a dimensional relationship (2D, 3D, 2DM...)

     */

    private int subType;

    /**

     * Super types of a geometry. e.g: the super type of an arc is a curve, the

     * super type of a circle is a surface... The supertypes are defined in the

     * ISO 19107

     *

     * @see <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=26012"

     * >ISO 19107< /a>

     */

    private int[] superTypes = null;

    /**

     * Super SubTypes of a geometry. e.g: the super SubType of a geometry 3D is

     * a geometry 2D, because the 3D extends the behavior of a geometry 2D

     */

    private int[] superSubTypes = null;

    private Constructor constructorWithGeometryType = null;

    private Constructor constructorWithoutParameters = null;

    private final Object[] parameters = {this};

    private Set<String> alias;

    /**

     * This constructor is used by the {@link GeometryManager} when it register

     * a new GeometryType.It has not be used from other parts.

     *

     * @param geomClass Geometry class (e.g: Point2D.class)

     * @param name Symbolic Geometry name that is used to persist the geometry

     * type. In some cases, it is better to use this name because the id can

     * change for different application executions.

     * @param type The geometry abstract type

     * @param subType

     * @param superTypes The superTypes of the geometry type

     * @param superSubTypes The superSubtypes of the geometry type

     */

    public DefaultGeometryType(Class geomClass, String name, int type, int subType,

            int[] superTypes, int[] superSubTypes) {

        this.geometryClass = geomClass;

        if (name == null) {

            this.name = geomClass.getName();

        } else {

            this.name = name;

        }

        this.type = type;

        this.subType = subType;

        this.superTypes = superTypes;

        this.superSubTypes = superSubTypes;

        Class[] parameterTypes = {GeometryType.class};

        try {

            constructorWithGeometryType = geometryClass.getConstructor(parameterTypes);

        } catch (NoSuchMethodException e) {

            try {

                constructorWithoutParameters = geometryClass.getConstructor();

            } catch (NoSuchMethodException e1) {

                throw new RuntimeException(

                        "Error constructor of the geometry class " + geomClass

                        + " with one parameter of type GeometryType not found", e);

            }

        }

    }

    /**

     * This constructor is used by the {@link GeometryManager} when it register

     * a new GeometryType.It has not be used from other parts.

     *

     * @param geomClass Geometry class (e.g: Point2D.class)

     * @param name Symbolic Geometry name that is used to persist the geometry

     * type. In some cases, it is better to use this name because the id can

     * change for different application executions.

     * @param type The geometry abstract type

     * @param subType

     */

    public DefaultGeometryType(Class geomClass, String name, int type, int subType) {

        this(geomClass, name, type, subType, new int[0], new int[0]);

    }

    /**

     * This method creates a {@link Geometry} with the type specified by this

     * GeometryType. The geometry has to have a constructor without arguments.

     *

     * @return A new geometry

     * @throws CreateGeometryException

     */

    @Override

    public Geometry create() throws CreateGeometryException {

        try {

            if (constructorWithGeometryType != null) {

                return (Geometry) constructorWithGeometryType.newInstance(parameters);

            } else {

                return (Geometry) constructorWithoutParameters.newInstance();

            }

        } catch (Exception e) {

            throw new CreateGeometryException(type, subType, e);

        }

    }

    @Override

    public Class getGeometryClass() {

        return geometryClass;

    }

    @Override

    public String getName() {

        return name;

    }

    @Override

    public String getFullName() {

        String subtypename;

        switch (this.subType) {

            case Geometry.SUBTYPES.GEOM2D:

                subtypename = "2D";

                break;

            case Geometry.SUBTYPES.GEOM2DM:

                subtypename = "2DM";

                break;

            case Geometry.SUBTYPES.GEOM3D:

                subtypename = "3D";

                break;

            case Geometry.SUBTYPES.GEOM3DM:

                subtypename = "3DM";

                break;

            default:

                subtypename = "subtype" + this.subType;

        }

        if (name.endsWith(subtypename)) {

            try {

                return name.substring(0, name.length() - subtypename.length()) + ":" + subtypename;

            } catch (Throwable th) {

                // 

            }

        }

        return name + ":" + subtypename;

    }

    @Override

    public int getType() {

        return type;

    }

    @Override

    public int getSubType() {

        return subType;

    }

    @Override

    public boolean isTypeOf(int geometryType) {

        if (type == geometryType) {

            return true;

        }

        for (int i = 0; i < superTypes.length; i++) {

            if (superTypes[i] == geometryType) {

                return true;

            }

        }

        return Geometry.TYPES.GEOMETRY == geometryType;

    }

    @Override

    public boolean isSubTypeOf(int geometrySubType) {

        if (subType == geometrySubType) {

            return true;

        }

        for (int i = 0; i < superSubTypes.length; i++) {

            if (superSubTypes[i] == geometrySubType) {

                return true;

            }

        }

        return false;

    }

    @Override

    public int getDimension() {

        switch (this.subType) {

            case Geometry.SUBTYPES.GEOM2D:

                return 2;

            case Geometry.SUBTYPES.GEOM3D:

            case Geometry.SUBTYPES.GEOM2DM:

                return 3;

            case Geometry.SUBTYPES.GEOM3DM:

                return 4;

            default:

                return -1;

        }

    }

    @Override

    public boolean equals(Object obj) {

        if (!(obj instanceof GeometryType)) {

            return false;

        }

        GeometryType other = (GeometryType) obj;

        if (!this.name.equals(other.getName())) {

            return false;

        }

        if (!this.geometryClass.getName().equals(other.getGeometryClass().getName())) {

            return false;

        }

        if (this.type != other.getType()) {

            return false;

        }

        if (this.subType != other.getSubType()) {

            return false;

        }

        return true;

    }

    @Override

    public int hashCode() {

        int hash = 7;

        hash = 79 * hash + Objects.hashCode(this.name);

        hash = 79 * hash + Objects.hashCode(this.geometryClass.getName());

        hash = 79 * hash + this.type;

        hash = 79 * hash + this.subType;

        return hash;

    }

    @Override

    public GeometryType addAlias(String alias) {

        if (this.alias == null) {

            this.alias = new HashSet<>();

        }

        this.alias.add(alias);

        return this;

    }

    @Override

    public Collection<String> getAlias() {

        if (this.alias == null) {

            return Collections.EMPTY_LIST;

        }

        return Collections.unmodifiableCollection(this.alias);

    }

}