/branches/v2_0_0_prep/libraries/libFMap_geometries/src/org/gvsig/fmap/geom/GeometryManager.java - Diff - | gvSIG desktop 1 - gvSIG

Revision 20953 branches/v2_0_0_prep/libraries/libFMap_geometries/src/org/gvsig/fmap/geom/GeometryManager.java

     import java.util.Map;
     import org.gvsig.fmap.geom.operation.GeometryOperation;
     import org.gvsig.fmap.geom.operation.GeometryOperationContext;
     import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;
     import org.gvsig.fmap.geom.type.GeometryType;
-...
     	/** Índice con el nombre único de cada operación */
     	private List geometryOperations = new ArrayList();
     	/** Las operaciones que son comunes a todos los tipos de geometría se registran aquí, el resto están en cada tipo de geometría */
     	private List commonOperations = new ArrayList();
     	/** Las operaciones comunes tienen un indice asignado a partir de este valor, se almacenan en una estructura distinta que las operaciones
     	 * que dependen del tipo y comparando con este valor sabemos a qué estructura acceder */
     	private static final int COMMON_OPS_OFFSET = 1000;
     	/** 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();
     	private int typeIndex = 128;
     	/** Contador de registro de tipos de geometría, se asigna en el momento de su registro */
     	private int geomTypeIndex = 100;
     	/**
     	 * Constructor privado (singleton)
-...
+    	}
     	/**
     	 * Registra el nombre de una operación. Este nombre es único en la aplicación.
     	 * @param geomOpName
     	 * @return
     	 */
     	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;
+    	}
     	/**
     	 * 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
-...
     	 */
     	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);
+    		}
     		int index = registerGeometryOperationName(geomOpName);
     		geomType.setGeometryOperation(index, geomOp);
     		return index;
+    	}
     	/**
     	 * Registra una operación que será común a todos los tipos de geometría.
     	 * @param geomOpName
     	 * @param geomOp
     	 * @return
     	 */
     	public int registerGeometryOperation(String geomOpName,
     			GeometryOperation geomOp) {
     		// FIXME Registrar operacion para todas las geom
     		return -1;
     		if (geomOpName == null)
     			throw new IllegalArgumentException("geomOpName cannot be null.");
     		if (geomOp == null)
     			throw new IllegalArgumentException("geomOp cannot be null.");
     		int index = registerGeometryOperationName(geomOpName);
     		commonOperations.add(index, geomOp);
     		return index + COMMON_OPS_OFFSET;
+    	}
     	public int registerGeometryOperation(String geomOpName,
-...
     	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;
     		GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();
     		return registerGeometryOperation(geomOpName, geomOp, geomType);
+    	}
     	/**
-...
     		// Si no está registrada, registrarla
     		if (geomType == null) {
     			geomType = new GeometryType(geomClass, name, typeIndex++);
     			geomType = new GeometryType(geomClass, name, geomTypeIndex++);
     			geometryTypes.put(geomClass.getName(), geomType);
+    		}
-...
+    		}
     		return null;
+    	}
     	/**
     	 * Invoca una operación dado su índice, la geometría y el contexto.
     	 * @param index
     	 * @param geom
     	 * @param ctx
     	 * @return
     	 */
     	public Object invokeOperation(int index, Geometry geom, GeometryOperationContext ctx) {
     		if (index < COMMON_OPS_OFFSET) {
     			return geom.getGeometryType().getGeometryOperation(index).invoke(geom, ctx);
     		} else {
     			return ((GeometryOperation)commonOperations.get(index - COMMON_OPS_OFFSET)).invoke(geom, ctx);
+    		}
+    	}
+    }

Also available in: Unified diff