| 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.GeometryOperationContext;

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

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

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

/**

 * This singleton provides a centralized access to gvSIG's Geometry Model.

 * Its responsibilities are:<br>

 * 

 * <ul>

 * <li>Offering a set of convenient methods for registering and retrieving geometry types.

 * <li>Offering a set of convenient methods for registering and retrieving geometry operations associated 

 * to one or more geometry types.

 * <li><code>TODO:</code> Offering a set of convenient methods for registering and retrieving custom 

 * geometry factories.

 * <ul>

 *  

 * @author jiyarza

 *

 */

public class GeometryManager {

        private static GeometryManager instance;

        /** This list holds the unique name of all registered geometry operations. 

         * The index in which they are stored is also the operation code used to invoke each one of them */

        private List geometryOperations = new ArrayList();

        /** Common operations are registered here. Type specific operations are registered in the corresponding GeometryType instance */ 

        private List commonOperations = new ArrayList();

        /** Common operations are assigned an index greater or equal than this constant, so that it is easy and efficient for the manager 

         * to decide whether to lookup in the common register or in the type specific register. */

        private static final int COMMON_OPS_OFFSET = 1000;

        /** This map holds the instances of all registered GeometryType. The key is the name of the specific Geometry subclass. 

         * In other words, the string "org.gvsig.fmap.geom.primitive.Point2D" is the hash key to obtain an instance of GeometryType holding the 

         * operations associated to the class org.gvsig.fmap.geom.primitive.Point2D.

         */

        private Map geometryTypes = new HashMap();

        /** GeometryType index counter. Each time a new geometry type is registered it is assigned this counter's value as index and after that 

         * it is incremented by 1 */

        private int geomTypeIndex = 100;

        /**

         * Singleton's private constructor

         */

        private GeometryManager() {

        }

        /**

         * Returns this singleton's unique instance

         * @return unique instance of GeometryManager

         */

        public static GeometryManager getInstance() {

                if (instance == null) {

                        instance = new GeometryManager();

                }

                return instance;

        }

        /**

         * Registers the unique name of one operation. If it already exists then this method does nothing but returning 

         * the name's corresponding index.  

         * @param geomOpName Name used to register the geometry operation

         * @return index assigned to the operation name passed as parameter

         */

        private int registerGeometryOperationName(String geomOpName) {

                if (geomOpName == null)

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

                int index = geometryOperations.indexOf(geomOpName);

                if (index == -1) {

                        geometryOperations.add(geomOpName);

                        index = geometryOperations.indexOf(geomOpName);

                }

                return index;

        }

        /**

         * Sets a common operation into the common operations map. 

         * @param index index in which to set the operation

         * @param geomOp operation to be set

         */

        private void setCommonOperation(int index, GeometryOperation geomOp) {

                while (index > commonOperations.size()) {

                        commonOperations.add(null);

                }

                if (index == commonOperations.size()) {

                        commonOperations.add(geomOp);

                } else {                                

                        commonOperations.set(index, geomOp);

                }

        }        

        /**

         * Registers a GeometryOperation associated to a GeometryType. 

         * Returns an unique index that is used later to identify and invoke the operation.

         * 

         * This method is only used if you already got a reference to the GeometryType. If not,

         * it is more convenient to use the method that receives the geometry class as parameter. 

         *  

         * By convention, the return value should be stored in a public constant within the class implementing 

         * the operation:<BR>         

         * <pre>

         * public class MyOperation extends GeometryOperation {

         *   public static final int OPERATION_INDEX = 

         *     GeometryManager.getInstance()

         *        .registerGeometryOperation("MyOperation", new MyOperation(), geomType);

         * }

         * </pre>

         * @param geomOpName Operation's unique name

         * @param geomOp Specific GeometryOperation's instance implementing this operation

         * @param geomType GeometryType instance to which this operation should be associated

         * @return Index assigned to this operation. This index is used later to access the operation.

         * 

         */

        public int registerGeometryOperation(String geomOpName,

                        GeometryOperation geomOp, GeometryType geomType) {

                if (geomOp == null)

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

                if (geomType == null)

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

                int index = registerGeometryOperationName(geomOpName);

                geomType.setGeometryOperation(index, geomOp);

                return index;

        }

        /**

         * Registers a GeometryOperation that is common for all GeometryType (registered yet or not) 

         * Returns an unique index that is used later to identify and invoke the operation.

         *  

         * By convention, the return value should be stored in a public constant within the class implementing 

         * the operation:<BR>         

         * <pre>

         * public class MyOperation extends GeometryOperation {

         *   public static final int OPERATION_INDEX = 

         *     GeometryManager.getInstance()

         *        .registerGeometryOperation("MyOperation", new MyOperation());

         * }

         * </pre>

         *  

         * @param geomOpName Operation's unique name

         * @param geomOp Specific GeometryOperation's instance implementing this operation

         * @return Index assigned to this operation. This index is used later to access the operation. 

         */

        public int registerGeometryOperation(String geomOpName,

                        GeometryOperation geomOp) {

                if (geomOpName == null)

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

                if (geomOp == null)

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

                int index = registerGeometryOperationName(geomOpName);

                setCommonOperation(index, geomOp);

                return index + COMMON_OPS_OFFSET;

        }

        /**

         * Registers a GeometryOperation associated to a GeometryType. 

         * Returns an unique index that is used later to identify and invoke the operation.<br>

         *  

         * By convention, the return value should be stored in a public constant within the class implementing 

         * the operation:<BR>         

         * <pre>

         * public class MyOperation extends GeometryOperation {

         *   public static final int OPERATION_INDEX = 

         *     GeometryManager.getInstance()

         *        .registerGeometryOperation("MyOperation", new MyOperation(), MyGeometry.class);

         * }

         * </pre>

         * 

         * This method is only used if you have not a reference to the GeometryType associated to the

         * geometry class. If you have such reference then it is slightly faster to use the method that receives

         * the GeometryType.<br>

         * 

         * @param geomOpName Operation's unique name

         * @param geomOp Specific GeometryOperation's instance implementing this operation

         * @param geomClass Geometry implementation class

         * @return Index assigned to this operation. This index is used later to access the operation.

         */        

        public int registerGeometryOperation(String geomOpName,

                        GeometryOperation geomOp, Class geomClass) {

                GeometryType geomType = getGeometryType(geomClass);

                return registerGeometryOperation(geomOpName, geomOp, geomType);

        }

        /**

         * Registers a GeometryOperation associated to a GeometryType. 

         * Returns an unique index that is used later to identify and invoke the operation.<br>

         *  

         * By convention, the return value should be stored in a public constant within the class implementing 

         * the operation:<BR>         

         * <pre>

         * public class MyOperation extends GeometryOperation {

         *   public static final int OPERATION_INDEX = 

         *     GeometryManager.getInstance()

         *        .registerGeometryOperation("MyOperation", MyOperation.class, myGeomType);

         * }

         * </pre>

         *

         * @param geomOpName Operation's unique name

         * @param geomOpClass GeometryOperation class

         * @param geomType GeometryType instance to which this operation should be associated

         * @return Index assigned to this operation. This index is used later to access the operation.

         * @throws IllegalAccessException, {@link InstantiationException} Either exception maybe thrown when

         * trying to instance the geometry operation class.

         */

        public int registerGeometryOperation(String geomOpName, Class geomOpClass,

                        GeometryType geomType)

                        throws IllegalAccessException, InstantiationException {

                GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();                

                return registerGeometryOperation(geomOpName, geomOp, geomType);                

        }

        /**

         * Registers a Geometry implementation class as a new geometry type and returns the 

         * associated GeometryType instance. If the class is already registered

         * then this method does nothing but returning the associated GeometryType.<br>

         * 

         * @param geomClass

         *            Geometry subclass. It must not be null and must implement Geometry, otherwise an exception 

         *            is raised.

         * @param name

         *                           Symbolic name for the geometry type, it can be null. If it is null then the symbolic name 

         *                       will be the simple class name.

         * @return Instance of GeometryType associated to the Geometry implementation class

         *         geomClass

         * @throws IllegalArgumentException

         *             If geomClass is null or does not implement Geometry

         */

        public GeometryType registerGeometryType(Class geomClass, String name) {

                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, name, geomTypeIndex++);

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

                }

                return geomType;

        }

        /**

         * Registers a Geometry implementation as a new geometry type and returns the 

         * associated GeometryType instance. If the class is already registered

         * then this method does nothing but returning the associated GeometryType.<br>

         * 

         * @param geomClass

         *            Geometry implementation class. It must not be null and must implement Geometry, 

         *            otherwise an exception is thrown.

         * @param name

         *                           Symbolic name for the geometry type, it can be null. If it is null then the symbolic name 

         *                       will be the simple class name.

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

         *         geomClass

         * @throws IllegalArgumentException

         *             If geomClass is null or does not implement Geometry

         */

        public GeometryType registerGeometryType(Class geomClass) {

                return registerGeometryType(geomClass, null);

        }

        /**

         * Returns an instance of GeometryType given the associated Geometry implementation 

         * class.

         * 

         * @param geomClass

         * @return Instance of GeometryType associated to geomClass

         */

        public GeometryType getGeometryType(Class geomClass) {

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

        }

        /**

         * Returns the associated GeometryType given the fully qualified name of

         * the Geometry implementation class.

         * 

         * @param className

         *            Fully qualified name of the Geometry implementation class

         * @return GeometryType associated to the class

         */

        public GeometryType getGeometryType(String className) {

                return (GeometryType) geometryTypes.get(className);

        }

        /**

         * Returns an operation given the Geometry implementation class and the operation 

         * index.

         * 

         * @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;

        }

        /**

         * Invokes an operation given its code, the geometry and the operation context holding the 

         * parameters required for the operation.

         * 

         * @param opCode Operation code.

         * @param geom Geometry to which apply the operation

         * @param ctx Context holding the operation parameters

         * @return The object returned by an operation, depends on each operation. 

         */

        public Object invokeOperation(int opCode, Geometry geom, GeometryOperationContext ctx) throws GeometryOperationNotSupportedException, GeometryOperationException {

                GeometryOperation geomOp = null;

                if (opCode < COMMON_OPS_OFFSET) {

                        geomOp =  geom.getGeometryType().getGeometryOperation(opCode);

                } else {

                        geomOp = ((GeometryOperation)commonOperations.get(opCode - COMMON_OPS_OFFSET));

                }

                if (geomOp != null) {

                        return geomOp.invoke(geom, ctx);

                }

                throw new GeometryOperationNotSupportedException(opCode, geom.getGeometryType());

        }

}