Application: gvSIG desktop

/* 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.apache.log4j.Logger;

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;

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

/**

 * 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 Logger logger = Logger.getLogger(GeometryManager.class);

        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 = 65536;//2^16

        /**

         * Geometry Factory

         */

        private GeometryFactory factory = new GeometryFactory();

        /**

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

                        instance.registerGeometryFactory(new GeometryFactory());

                }

                return instance;

        }

        /**

         * Registers a GeometryFactory that will be used instead of the default one.

         * @param factory

         */

        public void registerGeometryFactory(GeometryFactory factory) {

                this.factory = factory;

        }

        /**

         * Returns the current geometry factory

         * @return

         */

        public GeometryFactory getGeometryFactory() {

                return factory;

        }

        /**

         * 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 CODE =

         *     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 CODE =

         *     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 CODE =

         *     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 CODE =

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

         *

         * How to register a new geometry type:

         * <pre>

         *

         * public class MyGeom3D implements Solid {

         *   private static final GeometryType geomType = GeometryManager.getInstance()

         *           .registerGeometryType(MyGeom3D.class, "MyGeom3D");

         *

         *   public static final int .CODE = geomType.getType();

         * ...

         *   public int getType() {

         *      return .CODE;

         *   }

         * }

         * </pre>

         *

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

                }

                // Check if it is registered

                GeometryType geomType = (GeometryType) geometryTypes.get(geomClass

                                .getName());

                // If it is not, register it

                if (geomType == null) {

                        geomType = new GeometryType(geomClass, name, geomTypeIndex++);

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

                } else {

                        // If it is already registered, throw exception

                        throw new IllegalArgumentException("Attempt to register a geometry type that is already registered: " + geomClass.getName());

                }

                logger.debug("Class " + geomType.getGeometryClass().getName() + " registered with name " + geomType.getName());

                return 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>

         *

         * How to register a new geometry type:

         * <pre>

         *

         * public class MyGeom3D implements Solid {

         *   private static final GeometryType geomType = GeometryManager.getInstance()

         *           .registerBasicGeometryType(Point2D.class, "Point2D",Geometry.TYPES.POINT);

         *

         *   public static final int .CODE = geomType.getType();

         * ...

         *   public int getType() {

         *      return .CODE;

         *   }

         * }

         * </pre>

         *

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

         * @param type

         *                           Type of basic geometry.

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

         *         geomClass

         * @throws IllegalArgumentException

         *             If geomClass is null or does not implement Geometry

         */

        public GeometryType registerBasicGeometryType(Class geomClass, String name,int type){

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

                }

                // Check if it is registered

                GeometryType geomType = (GeometryType) geometryTypes.get(geomClass

                                .getName());

                // If it is not, register it

                if (geomType == null) {

                        geomType = new GeometryType(geomClass, name, type);

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

                } else {

                        // If it is already registered, throw exception

                        throw new IllegalArgumentException("Attempt to register a geometry type that is already registered: " + geomClass.getName());

                }

                logger.debug("Class " + geomType.getGeometryClass().getName() + " registered with name " + geomType.getName());

                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>

         *

         * In this case the symbolic name will be the geometry's simple class name

         *

         * How to register a new geometry type:

         * <pre>

         *

         * public class MyGeom3D implements Solid {

         *   private static final GeometryType geomType = GeometryManager.getInstance()

         *           .registerGeometryType(MyGeom3D.class);

         *

         *   public static final int .CODE = geomType.getType();

         * ...

         *   public int getType() {

         *      return .CODE;

         *   }

         * }

         * </pre>

         *

         * @param geomClass

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

         *            otherwise an exception is thrown.

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

         * @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 the Geometry implementation class

         */

        public GeometryType getGeometryType(Class geomClass) {

                logger.debug("getting " + geomClass.getName());

                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

         * code. If opCode corresponds to a common operation (a common operation is an operation

         * registered for all geometries), then this method returns the common operation.

         * <br>

         * For better performance, if you need to call an operation multiple times,

         * use this method only once and keep the returned object in a local variable

         * over which you can iterate. For instance:

         *

         * <pre>

         * ...

         *  // Get the operation you need

         * GeometryManager gm = GeometryManager.getInstance();

         * GeometryOperation geomOp = null;

         * try {

         *    geomOp = gm.getGeometryOperation(Point2D.class, Draw2D.CODE);

         * } catch (GeometryTypeNotSupportedException gtnse) {

         *    // treat exception

         * } catch (GeometryOperationNotSupportedException gonse) {

         *    // treat exception

         * }

         *

         *  // Fill the operation context with required params

         * GeometryOperationContext ctx = new GeometryOperationContext();

         *

         *  // Here is the main loop where you call the operation

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

         *    Object result = geomOp.invoke(myGeometries[i], ctx);

         * }

         *

         * </pre>

         *

         * @param geomClass

         * @param opCode

         * @return Geometry operation

         */

        public GeometryOperation getGeometryOperation(Class geomClass, int opCode) throws GeometryTypeNotSupportedException, GeometryOperationNotSupportedException {

                GeometryOperation geomOp = null;

                // Check if it is a common operation, and if so, get it from the common registry

                if (opCode >= COMMON_OPS_OFFSET) {

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

                        if (geomOp == null) {

                                throw new GeometryOperationNotSupportedException(opCode);

                        }

                } else {

                        // If it is type specific, get it from its type        registry

                        if (geomClass != null) {

                                GeometryType geomType = getGeometryType(geomClass);

                                // If the geometry type is not registered, throw an exception

                                if (geomType == null) {

                                        throw new GeometryTypeNotSupportedException(geomClass);

                                }

                                // Get the operation

                                geomOp = geomType.getGeometryOperation(opCode);

                                // If the operation is not registered throw an exception

                                if (geomOp == null) {

                                        throw new GeometryOperationNotSupportedException(opCode, geomType);

                                }

                        }

                }

                return geomOp;

        }

        /**

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

        }

}