| gvSIG desktop 1

/* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib��ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package org.gvsig.fmap.geom;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.geom.operation.GeometryOperation;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

public class GeometryManager {

        private static GeometryManager instance;

        /** Índice con el nombre único de cada operación */

        private List geometryOperations = new ArrayList();

        /** Mapa con las instancias de cada tipo de geometría, la clave es el nombre de la clase de geometría. 

         * Es decir para "org.gvsig.fmap.geom.Point2D" se obtiene una instancia de GeometryType que contiene las 

         * operaciones asociadas a Point2D.

         */

        private Map geometryTypes = new HashMap();

        /**

         * Constructor privado (singleton)

         */

        private GeometryManager() {

        }

        /**

         * Método para obtener la instancia única (singleton)

         * @return

         */

        public static GeometryManager getInstance() {

                if (instance == null) {

                        instance = new GeometryManager();

                }

                return instance;

        }

        /**

         * Método para registrar una operación asociada a un tipo de geometría.

         * 

         * @param geomOpName Nombre de la operación, este nombre es único

         * @param geomOp Instancia de GeometryOperation que implementa la operación

         * @param geomType Instancia de GeometryType a la que se asocia la operación

         * @return índice asignado a la operación. Este índice se debe usar despues para acceder a la operación

         * 

         */

        public int registerGeometryOperation(String geomOpName,

                        GeometryOperation geomOp, GeometryType geomType) {

                if (geomOpName == null)

                        throw new IllegalArgumentException("geomOpName cannot be null.");

                if (geomOp == null)

                        throw new IllegalArgumentException("geomOp cannot be null.");

                if (geomType == null)

                        throw new IllegalArgumentException("geomType cannot be null.");

                int index = geometryOperations.indexOf(geomOpName);

                if (index == -1) {

                        geometryOperations.add(geomOpName);

                        index = geometryOperations.indexOf(geomOpName);

                }

                geomType.setGeometryOperation(index, geomOp);

                return index;

        }

        /**

         * 

         * @param geomOpName

         * @param geomOpClass

         * @param geomType

         * @return

         * @throws GeometryOperationNotSupportedException

         */

        public int registerGeometryOperation(String geomOpName, Class geomOpClass,

                        GeometryType geomType)

                        throws IllegalAccessException, InstantiationException {

                if (geomOpName == null)

                        throw new IllegalArgumentException("geomOpName cannot be null.");

                if (geomOpClass == null)

                        throw new IllegalArgumentException("geomOpClass cannot be null.");

                if (geomType == null)

                        throw new IllegalArgumentException("geomType cannot be null.");

                int index = geometryOperations.indexOf(geomOpName);

                if (index == -1) {

                        geometryOperations.add(geomOpName);

                        index = geometryOperations.indexOf(geomOpName);

                }

                geomType.setGeometryOperation(index, (GeometryOperation) geomOpClass.newInstance());

                return index;

        }

        /**

         * Registra una clase de geometría y devuelve la instancia GeometryType

         * asociada. Si la clase ya está registrada sólo se devuelve la instancia

         * GeometryType asociada.

         * 

         * geomClass no debe ser nulo y debe implementar la interfaz Geometry, en

         * caso contrario se lanza una excepción.

         * 

         * @param geomClass

         *            Clase de Geometry

         * @return Instancia de GeometryType asociada a la clase de geometría

         *         geomClass

         * @throws IllegalArgumentException

         *             si geomClass es nulo o no implementa Geometry

         */

        public GeometryType registerGeometryType(Class geomClass) {

                if (geomClass == null) {

                        throw new IllegalArgumentException("geomClass cannot be null.");

                }

                if (!Geometry.class.isAssignableFrom(geomClass)) {

                        throw new IllegalArgumentException(geomClass.getName()

                                        + " must implement the Geometry interface");

                }

                // Comprobar si ya está registrada

                GeometryType geomType = (GeometryType) geometryTypes.get(geomClass

                                .getName());

                // Si no está registrada, registrarla

                if (geomType == null) {

                        geomType = new GeometryType(geomClass);

                        geometryTypes.put(geomClass.getName(), geomType);

                }

                return geomType;

        }

        /**

         * Devuelve un GeometryType dada la clase que lo implementa

         * 

         * @param geomClass

         * @return

         */

        public GeometryType getGeometryType(Class geomClass) {

                return (GeometryType) geometryTypes.get(geomClass.getName());

        }

        /**

         * Devuelve un GeometryType dado el nombre cualificado de la clase de

         * geometría

         * 

         * @param className

         *            Nombre cualificado de la clase de geometría

         * @return GeometryType asociado

         */

        public GeometryType getGeometryType(String className) {

                return (GeometryType) geometryTypes.get(className);

        }

        /**

         * Devuelve una operación dada la clase de geometría y el índice de la

         * operación. Este índice se obtiene al registrar la operación.

         * 

         * @param geomClass

         * @param index

         * @return

         */

        public GeometryOperation getGeometryOperation(Class geomClass, int index) {

                GeometryType geomType = getGeometryType(geomClass);

                if (geomType != null) {

                        return geomType.getGeometryOperation(index);

                }

                return null;

        }

}