/ - Diff - Application: gvSIG desktop - gvSIG

Revision 21047

     /**
      * This singleton provides a centralized access to gvSIG's Geometry Model.
      * Its responsibilities are:
      * Its responsibilities are:<br>
+     *
      * Offering a set of convenient methods for registering geometry types.
      * Offering a set of convenient methods for registering geometry operations associated
      * <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.
      * TODO Offering a set of convenient methods for registering custom geometry factories.
      * <li><code>TODO:</code> Offering a set of convenient methods for registering and retrieving custom
      * geometry factories.
      * <ul>
+     *
+     *
      * @author jiyarza
+     *
      */
-...
     	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 where to lookup, in the common register or in type specific register. */
     	 * 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.
-...
     		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>
-...
     	 * public class MyOperation extends GeometryOperation {
     	 *   public static final int OPERATION_INDEX =
     	 *     GeometryManager.getInstance()
     	 *        .registerGeometryOperation("MyOperation", new MyOperation(), );
     	 *        .registerGeometryOperation("MyOperation", new MyOperation(), geomType);
     	 * }
     	 * </pre>
     	 * @param geomOpName Operation's unique name
-...
     	 * @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) {
-...
+    	}
     	/**
     	 * 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.<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) {
-...
     	/**
+    	 *
     	 * @param geomOpName
     	 * @param geomOpClass
     	 * @param geomType
     	 * @return
     	 * @throws GeometryOperationNotSupportedException
     	 * 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)
-...
+    	}
     	/**
     	 * 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.
     	 * 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>
+    	 *
     	 * geomClass no debe ser nulo y debe implementar la interfaz Geometry, en
     	 * caso contrario se lanza una excepci?n.
+    	 *
     	 * @param geomClass
     	 *            Clase de Geometry
     	 *            Geometry subclass. It must not be null and must implement Geometry, otherwise an exception
     	 *            is raised.
     	 * @param name
     	 * 			  Nombre simb?lico del tipo de geometr?a. Si se pasa un null entonces
     	 *            se toma como nombre simb?lico el nombre simple de la clase.
     	 * @return Instancia de GeometryType asociada a la clase de geometr?a
     	 * 			  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
     	 *             si geomClass es nulo o no implementa Geometry
     	 *             If geomClass is null or does not implement Geometry
     	 */
     	public GeometryType registerGeometryType(Class geomClass, String name) {
-...
+    	}
     	/**
     	 * 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. Como nombre simb?lico se fija el nombre simple
     	 * de la clase.
     	 * 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>
+    	 *
     	 * geomClass no debe ser nulo y debe implementar la interfaz Geometry, en
     	 * caso contrario se lanza una excepci?n.
+    	 *
     	 * @param geomClass
     	 *            Clase de Geometry
     	 *            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
     	 *             si geomClass es nulo o no implementa Geometry
     	 *             If geomClass is null or does not implement Geometry
     	 */
     	public GeometryType registerGeometryType(Class geomClass) {
     		return registerGeometryType(geomClass, null);
+    	}
     	/**
     	 * Devuelve un GeometryType dada la clase que lo implementa
     	 * Returns an instance of GeometryType given the associated Geometry implementation
     	 * class.
+    	 *
     	 * @param geomClass
     	 * @return
     	 * @return Instance of GeometryType associated to geomClass
     	 */
     	public GeometryType getGeometryType(Class geomClass) {
     		return (GeometryType) geometryTypes.get(geomClass.getName());
+    	}
     	/**
     	 * Devuelve un GeometryType dado el nombre cualificado de la clase de
     	 * geometr?a
     	 * Returns the associated GeometryType given the fully qualified name of
     	 * the Geometry implementation class.
+    	 *
     	 * @param className
     	 *            Nombre cualificado de la clase de geometr?a
     	 * @return GeometryType asociado
     	 *            Fully qualified name of the Geometry implementation class
     	 * @return GeometryType associated to the class
     	 */
     	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.
     	 * Returns an operation given the Geometry implementation class and the operation
     	 * index.
+    	 *
     	 * @param geomClass
     	 * @param index
-...
+    	}
     	/**
     	 * Invoca una operaci?n dado su ?ndice, la geometr?a y el contexto con los par?metros.
     	 * @param index
     	 * @param geom
     	 * @param ctx
     	 * @return
     	 * 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 index, Geometry geom, GeometryOperationContext ctx) throws GeometryOperationNotSupportedException, GeometryOperationException {
     	public Object invokeOperation(int opCode, Geometry geom, GeometryOperationContext ctx) throws GeometryOperationNotSupportedException, GeometryOperationException {
     		GeometryOperation geomOp = null;
     		if (index < COMMON_OPS_OFFSET) {
     			geomOp =  geom.getGeometryType().getGeometryOperation(index);
     		if (opCode < COMMON_OPS_OFFSET) {
     			geomOp =  geom.getGeometryType().getGeometryOperation(opCode);
     		} else {
     			geomOp = ((GeometryOperation)commonOperations.get(index - COMMON_OPS_OFFSET));
     			geomOp = ((GeometryOperation)commonOperations.get(opCode - COMMON_OPS_OFFSET));
+    		}
     		if (geomOp != null) {
     			return geomOp.invoke(geom, ctx);
+    		}
     		throw new GeometryOperationNotSupportedException(index, geom.getGeometryType());
     		throw new GeometryOperationNotSupportedException(opCode, geom.getGeometryType());
+    	}
+    }

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.Geometry;
     public interface Circle extends Arc {
     	/** This predefined geometry's type */
     	public static final int GEOM_TYPE = Geometry.TYPES.CIRCLE;
+    }

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.Geometry;
     public interface Arc extends Curve {
     	/** This predefined geometry's type */
     	public static final int GEOM_TYPE = Geometry.TYPES.ARC;
+    }

     package org.gvsig.fmap.geom.primitive;
     import org.gvsig.fmap.geom.Geometry;
     /* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
-...
      * @author Jorge Piera Llodr� (jorge.piera@iver.es)
      */
     public interface Curve extends OrientableCurve{
     	public static final int GEOM_TYPE = 2;
     	/** This predefined geometry's type */
     	public static final int GEOM_TYPE = Geometry.TYPES.CURVE;
+    }

     /* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana
     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.
+     *
-...
+     *
      *  Generalitat Valenciana
      *   Conselleria d'Infraestructures i Transport
      *   Av. Blasco Ib��ez, 50
      *   Av. Blasco Ib??ez, 50
      *   46010 VALENCIA
      *   SPAIN
+     *
-...
     import org.gvsig.fmap.geom.type.GeometryType;
     /**
      * Interfaz de Geometr?a.
+     *
      * @author $author$
      * Root interface in the geometry model.
      */
     public interface Geometry extends Shape, Serializable {
     	/**
     	 * Predefined geometry types in the model
     	 */
     	public interface TYPES {
     		/**
     		 * Unknown or not defined type.
-...
     		public final static int Z=8192;
+    	}
     //	/** Tipo de geometr?a de esta interfaz*/
     //	public final static int GEOM_TYPE = TYPES.NULL;
     	public static int BEST = 0;
     	public static int N = 1;
     	public static int NE = 2;
-...
     	public static int STRETCHINGHANDLER=1;
     	/**
     	 * Obtiene el tipo de la geometr?a
     	 * Returns the FShape type of the geometry.
+    	 *
     	 * @return una de las constantes de FShape: POINT, LINE, POLIGON
     	 * @deprecated
     	 * @return One FShape constant: {@link FShape}
     	 * @deprecated Use {@link getType} instead
     	 */
     	public int getShapeType();
     	/**
     	 * Devuelve el valor de la cte del tipo de geometr?a.
     	 * If this geometry is a predefined interface then this method returns one of {@link Geometry.TYPES} contants.<br>
     	 * If this geometry is an extended type then this method returns a runtime constant that identifies its type.
     	 * By convention this value is stored in a constant called GEOM_TYPE within the geometry class, for instance: Point2D.GEOM_TYPE.
+    	 *
     	 * @return
     	 * @return If this geometry is a predefined interface then one of {@link Geometry.TYPES} or a runtime constant if
     	 * it is an extended type.
     	 */
     	public int getType();
     	/**
     	 * Clona la Geometr�a.
     	 * Creates a clone of this geometry
+    	 *
     	 * @return Geometr�a clonada.
     	 * @return A clone of this geometry.
     	 */
     	public Geometry cloneGeometry();
     	/**
     	 * Devuelve true si la geometr�a intersecta con el rect�ngulo que se pasa
     	 * como par�metro.
     	 * Returns true if this geometry intersects the rectangle passed as parameter
+    	 *
     	 * @param r Rect�ngulo.
     	 * @param r Rectangle.
+    	 *
     	 * @return True, si intersecta.
     	 * @return True, if <code>this</code> intersects <code>r</code>.
     	 */
     	public boolean intersects(Rectangle2D r);
     	/**
     	 * Devuelve true si la geometr�a contiene al rect�ngulo que se pasa
     	 * como par�metro.
+    	 *
     	 * @param r Rect�ngulo.
+    	 *
     	 * @return True, si intersecta.
     	 */
     	//boolean contains(IGeometry g);
     	/**
     	 * Se usa en las strategies de dibujo para comprobar de manera r�pida
     	 * si intersecta con el rect�ngulo visible
     	 * Used by the drawing strategies to quickly test whether this geometry
     	 * intersects with the visible rectangle.
+    	 *
     	 * @param x
     	 * @param y
     	 * @param w
     	 * @param h
     	 * @return
     	 * @param y
     	 * @param w Width
     	 * @param h Height
     	 * @return true if <code>this</code> intersects the rectangle defined by the parameters
     	 */
     	public boolean fastIntersects(double x, double y, double w, double h);
     	/**
     	 * Devuelve el Rect�ngulo que ocupa la geometr�a.
     	 * Returns this geometry's boundary rectangle.
+    	 *
     	 * @return Rect�ngulo.
     	 * @return Boundary rectangle.
     	 */
     	public Rectangle2D getBounds2D();
     	/**
     	 * Reproyecta la geometr�a a partir del transformador de coordenadas.
     	 * Reprojects this geometry by the coordinate transformer passed as parameter.
+    	 *
     	 * @param ct Coordinate Transformer.
     	 */
     	public void reProject(ICoordTrans ct);
     	/**
     	 * Devuelve el GeneralPathXIterator con la informaci�n relativa a la geometr�a.
     	 * @param at TODO
     	 * Returns the GeneralPathXIterator with this geometry's information
     	 * @param at AffineTransform
+    	 *
     	 * @return PathIterator.
     	 */
     	public PathIterator getPathIterator(AffineTransform at);
         /**
     	 * It returns the handlers of the geomety,
     	 * these they can be of two types is straightening and of seleccion.
     	 * It returns the handlers of the geometry,
     	 * these they can be of two types is straightening and of selection.
+    	 *
     	 * @param type Type of handlers
+    	 *
-...
     	public boolean isSimple();
     	/**
     	 * @param index
     	 * @return
     	 * Invokes a geometry operation given its index and context
     	 * @param index unique index of the operation. Operation code.
     	 * @return object returned by the operation.
     	 */
     	public Object invokeOperation(int index, GeometryOperationContext ctx) throws GeometryOperationNotSupportedException, GeometryOperationException;
     	/**
     	 * Instance of the GeometryType associated to this geometry
     	 * @return
     	 */
     	public GeometryType getGeometryType();
+    }

     /*
      * Created on 08-jun-2004
+     *
      * TODO To change the template for this generated file go to
      * Window - Preferences - Java - Code Generation - Code and Comments
      */
     /* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana
+     *
      * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

     import java.util.Map;
     /**
      * Clase base que sirve de contenedor de parámetros
      * para las operaciones sobre geometrías.
      * This class is a default parameter container for geometry operation.<br>
+     *
      * Normalmente cada GeometryOperation deberá extender esta clase
      * e identificar los parámetros mediante getters/setters.
      * Normally every GeometryOperation will extend this class and identify
      * its parameters publicly with getters/setters
+     *
      * For those operations that need high performance, parameters should be declared as class
      * members instead of using the setAttribute/getAttribute mechanism. This way you avoid a hash
      * and a cast operation.
+     *
      * Para aquellas operaciones que requieran eficiencia, se deberá
      * declarar los parámetros de la operación como miembros de la clase
      * en vez de usar el mecanismo por defecto (getAttribute/setAttribute),
      * de este modo se evita el acceso <i>hash</i> y el <i>cast</i> posterior.
+     *
      * @author jyarza
+     *
      */
-...
     	private Map ctx = new HashMap();
     	/**
     	 * Returns an attribute given its name.
     	 * If it does not exist returns <code>null</code>
     	 * @param name
     	 * @return attribute
     	 */
     	public Object getAttribute(String name) {
     		return ctx.get(name);
+    	}
     	/**
     	 * Sets an attribute
     	 * @param name
     	 * @param value
     	 */
     	public void setAttribute(String name, Object value) {
     		ctx.put(name, value);
+    	}

     import org.gvsig.fmap.geom.Geometry;
     /**
      * Every geometry operation that is registered dynamically must extend this class.<br>
+     *
      * The following example shows how to implement and register a custom operation:
+     *
      * <pre>
      * public class MyOperation extends GeometryOperation {
+     *
      *   // Check GeometryManager for alternative methods to register an operation
      *   public static final int OPERATION_INDEX =
      *     GeometryManager.getInstance()
      *        .registerGeometryOperation("MyOperation", new MyOperation(), geomType);
+     *
      *   public Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException {
      *        // Operation logic goes here
      *   }
+     *
      *   public int getOperationIndex() {
      *      return OPERATION_INDEX;
      *   }
+     *
      * }
      * </pre>
+     *
      * @author jiyarza
+     *
      */
     public abstract class GeometryOperation {
     	/**
     	 * Invokes this operation given the geometry and context
     	 * @param geom Geometry to which apply this operation
     	 * @param ctx Parameter container
     	 * @return Place-holder object that may contain any specific return value.
     	 * @throws GeometryOperationException The implementation is responsible to throw this exception when needed.
     	 */
     	public abstract Object invoke(Geometry geom, GeometryOperationContext ctx) throws GeometryOperationException;
     	/**
     	 * Returns the constant value that identifies this operation and that was obtained upon registering it.
     	 * @return operation unique index
     	 */
     	public abstract int getOperationIndex();
+    }

Also available in: Unified diff