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

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

     /**
      * 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
      * <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
      * <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.
     	/** 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 */
     	/** 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
     	/** 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
     	/** 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
     	/** 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 = 10000;
     	private int geomTypeIndex = 65536;//2^16
     	/**
     	 * Geometry Factory
     	 */
     	private GeometryFactory factory = new GeometryFactory();
     	/**
     	 * Singleton's private constructor
     	 */
-...
     	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.
     	 * 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
     	 */
-...
+    		}
     		return index;
+    	}
     	/**
     	 * Sets a common operation into the common operations map.
     	 * 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 {
     		} else {
     			commonOperations.set(index, geomOp);
+    		}
+    	}
+    	}
     	/**
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * 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>
     	 * 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 =
     	 *   public static final int CODE =
     	 *     GeometryManager.getInstance()
     	 *        .registerGeometryOperation("MyOperation", new MyOperation(), geomType);
     	 * }
-...
     	 * @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) {
-...
     			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)
     	 * 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>
+    	 *
     	 * 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 =
     	 *   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.
     	 * @return Index assigned to this operation. This index is used later to access the operation.
     	 */
     	public int registerGeometryOperation(String geomOpName,
     			GeometryOperation geomOp) {
-...
     		int index = registerGeometryOperationName(geomOpName);
     		setCommonOperation(index, geomOp);
     		return index + COMMON_OPS_OFFSET;
+    	}
     	/**
     	 * Registers a GeometryOperation associated to a GeometryType.
     	 * 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>
+    	 *
     	 * 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 =
     	 *   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.
     	 * 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>
+    	 *
     	 * 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 =
     	 *   public static final int CODE =
     	 *     GeometryManager.getInstance()
     	 *        .registerGeometryOperation("MyOperation", MyOperation.class, myGeomType);
     	 * }
-...
     	public int registerGeometryOperation(String geomOpName, Class geomOpClass,
     			GeometryType geomType)
     			throws IllegalAccessException, InstantiationException {
     		GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();
     		return registerGeometryOperation(geomOpName, geomOp, geomType);
     		GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();
     		return registerGeometryOperation(geomOpName, geomOp, geomType);
+    	}
     	/**
     	 * Registers a Geometry implementation class as a new geometry type and returns the
     	 * 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() {
-...
     	 *   }
     	 * }
     	 * </pre>
+    	 *
+    	 *
     	 * @param geomClass
     	 *            Geometry subclass. It must not be null and must implement Geometry, otherwise an exception
     	 *            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
     	 * 			  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
-...
     			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
     	 * 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() {
-...
     	 *   }
     	 * }
     	 * </pre>
+    	 *
+    	 *
     	 * @param geomClass
     	 *            Geometry implementation class. It must not be null and must implement Geometry,
     	 *            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
-...
     		return registerGeometryType(geomClass, null);
+    	}
     	/**
     	 * Returns an instance of GeometryType given the associated Geometry implementation
     	 * Returns an instance of GeometryType given the associated Geometry implementation
     	 * class.
+    	 *
+    	 *
     	 * @param geomClass
     	 * @return Instance of GeometryType associated to the Geometry implementation class
     	 */
-...
     	/**
     	 * 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
-...
+    	}
     	/**
     	 * Returns an operation given the Geometry implementation class and the operation
     	 * 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
     	 * 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
-...
     	 * } 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
+    	 *
     	 *  // 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;
     		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 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
     	 * 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.
     	 * @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());
+    	}
+    }

Also available in: Unified diff