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

Revision 31020 branches/v2_0_0_prep/libraries/libFMap_geometries/src/org/gvsig/fmap/geom/impl/DefaultGeometryManager.java

     import java.util.Map;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryException;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.Geometry.SUBTYPES;
-...
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import com.vividsolutions.jts.geom.GeometryFactory;
     /**
      * Default implementation for the {@link GeometryManager}. When the
      * application starts, this class is registered in the
-...
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class DefaultGeometryManager implements GeometryManager{
     public class DefaultGeometryManager implements GeometryManager {
     	private static final Logger logger = LoggerFactory.getLogger(GeometryManager.class);
     	private double flatness = 0.8;
     	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 Map geometryTypeName = new HashMap();
     	/**
     	 * This attribute is used to keep the relationship between type,
     	 * subtype and GeometryType. The key is the type and the
     	 * value is other Map with the GeometryTypes
     	 * Matrix of geometry types by type (row) and subtype (column). This matrix
     	 * will contain null values in the cells where a GeometryType hasn't been
     	 * registered.
     	 */
     	private Map geometrySubtypes = new HashMap();
     	private GeometryType[][] geometryTypes;
     	/**
     	 * This array contains all the geometry types.
     	 */
     	private ArrayList geometryTypeList = new ArrayList();
     	/** GeometryType index counter. Each time a new geometry type (not predefined) is registered it is assigned this counter's value as index and after that
     	 * it is incremented by 1 */
     	private int geometryTypeIndex = 0;//Geometry.EXTENDED_GEOMTYPE_OFFSET; //65536;//2^16
     	/**
     	 * Geometry Factory
     	 */
     	private GeometryFactory factory = new GeometryFactory();
     	// Initially create a matrix of 17 x 6, which are the current default
     	// types and subtypes. If another type or subtype is registered, the
     	// matrix will grow as needed
     	private static final int DEFAULT_TYPES_SIZE = 17;
     	private static final int DEFAULT_SUBTYPES_SIZE = 6;
     	/**
     	 * The GeometryManager has to have a public constructor
     	 * that will be invoked by a extension point.
     	 */
     	public DefaultGeometryManager() {
     		this.registerGeometryFactory(new GeometryFactory());
     		this(DEFAULT_TYPES_SIZE, DEFAULT_SUBTYPES_SIZE);
+    	}
     	/**
     	 * Registers a GeometryFactory that will be used instead of the default one.
     	 * @param factory
     	 */
     	private void registerGeometryFactory(GeometryFactory factory) {
     		this.factory = factory;
     	public DefaultGeometryManager(int initialTypesSize, int initialSubtypesSize) {
     		geometryTypes = new GeometryType[initialTypesSize][initialSubtypesSize];
+    	}
     	/**
     	 * Returns the current geometry factory
     	 * @return
     	 */
     	public GeometryFactory getGeometryFactory() {
     		return factory;
+    	}
     	/*
     	 * (non-Javadoc)
     	 * @see org.gvsig.fmap.geom.GeometryManager#registerGeometryOperation(java.lang.String, org.gvsig.fmap.geom.operation.GeometryOperation, org.gvsig.fmap.geom.type.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>
     	 * <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.
     	 */
     	private int registerGeometryOperation(String geomOpName,
     			GeometryOperation geomOp, Class geomClass) {
     	// /**
     	// * 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.
     	// */
     	// private int registerGeometryOperation(String geomOpName,
     	// GeometryOperation geomOp, Class geomClass) {
     	//
     	// GeometryType geomType = getGeometryType(geomClass);
     	// return registerGeometryOperation(geomOpName, geomOp, geomType);
     	// }
     		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.
     	// */
     	// private int registerGeometryOperation(String geomOpName, Class
     	// geomOpClass,
     	// GeometryType geomType)
     	// throws IllegalAccessException, InstantiationException {
     	//
     	// GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();
     	// 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.
     	 */
     	private int registerGeometryOperation(String geomOpName, Class geomOpClass,
     			GeometryType geomType)
     	throws IllegalAccessException, InstantiationException {
     		GeometryOperation geomOp = (GeometryOperation) geomOpClass.newInstance();
     		return registerGeometryOperation(geomOpName, geomOp, geomType);
+    	}
     	/* (non-Javadoc)
     	 * @see org.gvsig.fmap.geom.GeometryManager#registerGeometryOperation(java.lang.String, org.gvsig.fmap.geom.operation.GeometryOperation, int, int)
     	 */
-...
     			if ((type == geometryType.getType())) {
     				code = registerGeometryOperation(geomOpName, geomOp, geometryType);
+    			}
+    			{
+    			}
+    		}
     		return code;
+    	}
-...
     			if ((subType == geometryType.getSubType())) {
     				code = registerGeometryOperation(geomOpName, geomOp, geometryType);
+    			}
+    			{
+    			}
+    		}
     		return code;
+    	}
-...
+    		}
     		// Check if it is registered
     		GeometryType geomType = (GeometryType) geometryTypeName.get(geomClass
     				.getName());
     		// If it is not, register it
     		if (geomType == null) {
     			geomType = new DefaultGeometryType(geomClass, name, id, type, subType);
     		GeometryType geomType = null;
     		if (type >= geometryTypes.length || subType >= geometryTypes[0].length
     				|| (geomType = geometryTypes[type][subType]) == null) {
     			geomType =
     					new DefaultGeometryType(geomClass, name, id, type, subType);
     			registerGeometryType(geomType);
     			geometryTypeName.put(geomClass.getName(), geomType);
     			geometryTypeList.add(id, geomType);
     			Map subTypes = null;
     			Integer key = new Integer(type);
     			if (!geometrySubtypes.containsKey(key)){
     				subTypes = new HashMap();
     				geometrySubtypes.put(key, subTypes);
     			}else{
     				subTypes = (HashMap)geometrySubtypes.get(key);
+    			}
     			subTypes.put(new Integer(subType), geomType);
     		} else {
     			// If it is already registered, throw exception
     			geometryTypeIndex--;
     			//throw new IllegalArgumentException("Attempt to register a geometry type that is already registered: " + geomClass.getName());
+    		}
     		logger.debug("Class " + geomClass + " registered with name " + geomType.getName());
     		logger.debug("Class {} registered with name {}", geomClass,
     				geomType.getName());
     		return geomType;
+    	}
     	private void registerGeometryType(GeometryType geometryType) {
     		if (geometryType.getType() >= geometryTypes.length
     				|| geometryType.getSubType() >= geometryTypes[0].length) {
     			// Recreate the geometry type matrix if the types
     			// or subtypes don't fit
     			int newTypesSize =
     					geometryType.getType() < geometryTypes.length ? geometryTypes.length
     							: geometryType.getType() + 1;
     			int newSubTypesSize =
     					geometryType.getSubType() < geometryTypes[0].length ? geometryTypes[0].length
     							: geometryType.getSubType() + 1;
     			GeometryType[][] newMatrix =
     					new GeometryType[newTypesSize][newSubTypesSize];
     			for (int i = 0; i < geometryTypes.length; i++) {
     				System.arraycopy(geometryTypes[i], 0, newMatrix[i], 0,
     						geometryTypes[i].length);
+    			}
     			geometryTypes = newMatrix;
+    		}
     		geometryTypes[geometryType.getType()][geometryType.getSubType()] =
     				geometryType;
+    	}
     	/*
     	 * (non-Javadoc)
     	 * @see org.gvsig.fmap.geom.GeometryManager#registerGeometryType(java.lang.Class, int)
-...
     		return registerGeometryType(geomClass, null, type, subType);
+    	}
     	/**
     	 * Returns an instance of GeometryType given the associated Geometry implementation
     	 * class.
+    	 *
     	 * @param geomClass
     	 * @return Instance of GeometryType associated to the Geometry implementation class
     	 */
     	private GeometryType getGeometryType(Class geomClass) {
     		logger.debug("getting " + geomClass.getName());
     		return (GeometryType) geometryTypeName.get(geomClass.getName());
+    	}
     	// /**
     	// * Returns an instance of GeometryType given the associated Geometry
     	// implementation
     	// * class.
     	// *
     	// * @param geomClass
     	// * @return Instance of GeometryType associated to the Geometry
     	// implementation class
     	// */
     	// private GeometryType getGeometryType(Class geomClass) {
     	// logger.debug("getting " + geomClass.getName());
     	// return (GeometryType) geometryTypeName.get(geomClass.getName());
     	// }
     	/*
     	 * (non-Javadoc)
-...
     	 * @see org.gvsig.fmap.geom.GeometryManager#getGeometryType(int, int)
     	 */
     	public GeometryType getGeometryType(int type, int subType) throws GeometryTypeNotSupportedException, GeometryTypeNotValidException {
     		Iterator it = geometryTypeName.keySet().iterator();
     		while (it.hasNext()){
     			String className = (String)it.next();
     			GeometryType geometryType = getGeometryType(className);
     			if ((type == geometryType.getType()) &&
     					(subType == geometryType.getSubType())){
     				return geometryType;
+    			}
     			if (subType == SUBTYPES.UNKNOWN){
     				throw new GeometryTypeNotValidException(type, subType);
+    			}
     		GeometryType gType = null;
     		if (type >= geometryTypes.length || subType >= geometryTypes[0].length) {
     			throw new GeometryTypeNotValidException(type, subType);
+    		}
     		throw new GeometryTypeNotSupportedException(type, subType);
     		gType = geometryTypes[type][subType];
     		if (gType == null) {
     			throw new GeometryTypeNotSupportedException(type, subType);
+    		}
     		return gType;
     		// Iterator it = geometryTypeName.keySet().iterator();
     		// while (it.hasNext()){
     		// String className = (String)it.next();
     		// GeometryType geometryType = getGeometryType(className);
     		// if ((type == geometryType.getType()) &&
     		// (subType == geometryType.getSubType())){
     		// return geometryType;
     		// }
     		// if (subType == SUBTYPES.UNKNOWN){
     		// throw new GeometryTypeNotValidException(type, subType);
     		// }
     		// }
     		// throw new GeometryTypeNotSupportedException(type, subType);
+    	}
     	/*
-...
     	 * (non-Javadoc)
     	 * @see org.gvsig.fmap.geom.GeometryManager#create(int)
     	 */
     	public Geometry create(int type, int subType) throws CreateGeometryException{
     		if (!geometrySubtypes.containsKey(new Integer(type))){
     			throw new IllegalArgumentException("geometry type" + type + " has not been registered yet.");
     	public Geometry create(int type, int subType)
     			throws CreateGeometryException {
     		try {
     			return getGeometryType(type, subType).create();
     		} catch (GeometryException e) {
     			throw new CreateGeometryException(type, subType, e);
+    		}
     		Map subtypes = (Map)geometrySubtypes.get(new Integer(type));
     		if (!subtypes.containsKey(new Integer(subType))){
     			throw new IllegalArgumentException("geometry subtype" + subType + " has not been registered yet.");
+    		}
     		return ((GeometryType)subtypes.get(new Integer(subType))).create();
+    	}
-...
     	 * @see org.gvsig.fmap.geom.GeometryManager#createCurve(org.gvsig.fmap.geom.primitive.GeneralPathX, int)
     	 */
     	public Curve createCurve(GeneralPathX generalPathX, int subType)
     	throws CreateGeometryException {
     			throws CreateGeometryException {
     		Curve curve = (Curve)create(TYPES.CURVE, subType);
     		curve.setGeneralPath(generalPathX);
     		return curve;
-...
     	 * @see org.gvsig.fmap.geom.GeometryManager#createNullGeometry(int)
     	 */
     	public NullGeometry createNullGeometry(int subType)
     	throws CreateGeometryException {
     			throws CreateGeometryException {
     		NullGeometry nullGeom = (NullGeometry)create(TYPES.NULL, subType);
     		return nullGeom;
+    	}
-...
     	 * @see org.gvsig.fmap.geom.GeometryManager#createPoint(double, double, int)
     	 */
     	public Point createPoint(double x, double y, int subType)
     	throws CreateGeometryException {
     			throws CreateGeometryException {
     		Point point = (Point)create(TYPES.POINT, subType);
     		point.setX(x);
     		point.setY(y);
-...
     	 * @see org.gvsig.fmap.geom.GeometryManager#createSurface(org.gvsig.fmap.geom.primitive.GeneralPathX, int)
     	 */
     	public Surface createSurface(GeneralPathX generalPathX, int subType)
     	throws CreateGeometryException {
     			throws CreateGeometryException {
     		Surface surface = (Surface)create(TYPES.SURFACE, subType);
     		surface.setGeneralPath(generalPathX);
     		return surface;
-...
     	 */
     	public Envelope createEnvelope(double minX, double minY, double maxX,
     			double maxY, int subType) throws CreateEnvelopeException {
     		Envelope envelope = null;
     		org.gvsig.fmap.geom.primitive.Point min = null;
     		org.gvsig.fmap.geom.primitive.Point max = null;
     		try {
     			min = (org.gvsig.fmap.geom.primitive.Point)create(TYPES.POINT, subType);
     			GeometryType gType = getGeometryType(TYPES.POINT, subType);
     			min = (Point) gType.create();
     			min.setX(minX);
     			min.setY(minY);
     			max = (org.gvsig.fmap.geom.primitive.Point)create(TYPES.POINT, subType);
     			max = (Point) gType.create();
     			max.setX(maxX);
     			max.setY(maxY);
     		}catch (CreateGeometryException e){
     			// min = createPoint(minX, minY, subType);
     			// max = createPoint(maxX, maxY, subType);
     		} catch (CreateGeometryException e) {
     			throw new CreateEnvelopeException(subType, e);
     		} catch (GeometryTypeNotSupportedException e) {
     			throw new CreateEnvelopeException(subType, e);
     		} catch (GeometryTypeNotValidException e) {
     			throw new CreateEnvelopeException(subType, e);
+    		}
     		envelope = createEnvelope(subType);
     		envelope.setLowerCorner(min);
     		envelope.setUpperCorner(max);
     		return envelope;
     		switch (subType) {
     		case SUBTYPES.GEOM2D:
     		case SUBTYPES.GEOM2DM:
     			// Small optimization to directly create an Envelope2D
     			// return new Envelope2D(minX, minY, maxX, maxY);
     			return new Envelope2D(min, max);
     		default:
     			Envelope envelope = createEnvelope(subType);
     			envelope.setLowerCorner(min);
     			envelope.setUpperCorner(max);
     			return envelope;
+    		}
+    	}
     	public MultiCurve createMultiCurve(GeneralPathX generalPathX, int subType)
-...
+    	}
     	public MultiSurface createMultiSurface(GeneralPathX generalPathX,
     			int subType)
     			throws CreateGeometryException {
     			int subType) throws CreateGeometryException {
     		if (subType != SUBTYPES.GEOM2D) {
     			// FIXME Exception
     			throw new UnsupportedOperationException();
-...
     	 * @see org.gvsig.fmap.geom.GeometryManager#getGeometryOperationNames()
     	 */
     	public List getGeometryOperationNames() {
     		ArrayList operations = new ArrayList();
     		List operations = new ArrayList();
     		for (int i=0 ; i<operations.size() ; i++){
     			operations.add(geometryOperations.get(i));
+    		}
-...
     	public void setFlatness(double flatness) {
     		this.flatness = flatness;
+    	}
+    }
+    }

Also available in: Unified diff