/trunk/libraries/libTopology/src/org/gvsig/topology/Topology.java - Diff - Application: gvSIG desktop - gvSIG

Revision 19093 trunk/libraries/libTopology/src/org/gvsig/topology/Topology.java

      */
     /* CVS MESSAGES:
+     *
      * $Id:
      * $Log:
      * $Id:
      * $Log:
      */
     package org.gvsig.topology;
-...
     import com.iver.utiles.swing.threads.CancellableProgressTask;
     /**
+     *
+     *
      * This class represents a Topology, as a group of vectorial layers
      * and topology rules that checks geometries and their spatial relationships of
      * these layers.
+     *
+     *
      * It extends FLayers to reuse all already existent code related with
      * groups of layers (TOC related, etc.)
+     *
+     *
      * TODO Study if we must syncronize writing methods (validate, markAsException, addError,
      * ruleId++, etc)
+     *
-...
     public class Topology extends FLayers implements ITopologyStatus, ITopologyErrorContainer, Cloneable {
     	private static Logger logger = Logger.getLogger(Topology.class.getName());
     	private final static ImageIcon NOT_VALIDATED_TOC_ICON =
     	private final static ImageIcon NOT_VALIDATED_TOC_ICON =
     		new ImageIcon(Topology.class.getResource("images/topoicon.png"));
     	private final static ImageIcon VALIDATED_TOC_ICON =
     	private final static ImageIcon VALIDATED_TOC_ICON =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validated.png"));
     	private final static ImageIcon VALIDATED_WITH_ERRORS_TOC_ICON =
     	private final static ImageIcon VALIDATED_WITH_ERRORS_TOC_ICON =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validated_with_errors.png"));
     	private final static ImageIcon EMPTY_TOC_ICON =
     	private final static ImageIcon EMPTY_TOC_ICON =
     		new ImageIcon(Topology.class.getResource("images/topoicon_empty.png"));
     	private final static ImageIcon VALIDATED_WITH_DIRTY_ZONES_TOC_ICON =
     	private final static ImageIcon VALIDATED_WITH_DIRTY_ZONES_TOC_ICON =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validated_with_dirty_zones.png"));
     	private final static ImageIcon VALIDATING_TOC_ICON =
     	private final static ImageIcon VALIDATING_TOC_ICON =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validating.png"));
     	private ImageIcon statusIcon = EMPTY_TOC_ICON;
     	/**
     	 * topology name
     	 */
-...
     	/**
     	 * cluster tolerance of the topology
     	 */
     	private double clusterTolerance;
     	/**
-...
     	 */
     	private byte status = EMPTY;
     	/**
     	 * If during validation process a topoly exceeds this parameters, validation
     	 * will be stopped.
+    	 *
+    	 *
     	 */
     	private int maxNumberOfErrors = -1;
     	/**
     	 * topology rules of the topology
     	 */
     	private List<ITopologyRule> rules;
     	/**
     	 * Each layer of a topology must have a cluster tolerance rule
     	 */
     	private List<MustBeLargerThanClusterTolerance> clusterToleranceRules;
     	/**
     	 * Regions of the topology to be validated
     	 */
-...
     	 * responsability.
     	 */
     	private ITopologyErrorContainer errorContainer;
     	/**
     	 * Collection of error layers created from topology errors in topology
     	 * error container.
     	 */
     	private FLayer errorLayer;
     	/**
     	 * Registered class to listen for change status events.
     	 */
     	private List<ITopologyStatusListener> statusListeners;
     	/**
     	 * Map that relates a FLyrVect of the Topology with its rank (weight when we
     	 * are going to snap many coordinates)
     	 */
     	private Map<FLyrVect, XYZLayerRank> layerRanks;
     	/**
     	 * Numerical identifier for rules of a topology
     	 */
     	private int ruleId = 0;
     	/**
     	 * Interface for all of these classes interested in listening topology change status
     	 * events.
-...
     	public interface ITopologyStatusListener{
     		public void statusChange(TopologyStatusEvent event);
+    	}
     	/**
     	 * Topology change status event. It contains old and new topology status.
     	 * @author Alvaro Zabala
-...
     		int newStatus;
     		int prevStatus;
+    	}
     	/**
     	 * Default constructor for a topology as a FLayers
+    	 *
+    	 *
     	 * @param fmap
     	 * @param parent
     	 */
     	public Topology(MapContext fmap,
     					FLayers parent,
     					double clusterTolerance,
     	public Topology(MapContext fmap,
     					FLayers parent,
     					double clusterTolerance,
     					int numberOfErrors,
     					ITopologyErrorContainer errorContainer) {
     		super(fmap, parent);
     		super.setMapContext(fmap);
     		super.setParentLayer(parent);
     		this.clusterTolerance = clusterTolerance;
     		this.maxNumberOfErrors = numberOfErrors;
     		this.errorContainer = errorContainer;
     		this.errorContainer.setTopology(this);
     		rules = new ArrayList<ITopologyRule>();
     		clusterToleranceRules = new ArrayList<MustBeLargerThanClusterTolerance>();
     		dirtyZones = new ArrayList<Rectangle2D>();
     		layerRanks = new HashMap<FLyrVect, XYZLayerRank>();
     		statusListeners = new ArrayList<ITopologyStatusListener>();
     		//This listener updates the icon status returneb by this kind of layer
     		statusListeners.add(new ITopologyStatusListener(){
-...
     				case ITopologyStatus.VALIDATED:
     					statusIcon = VALIDATED_TOC_ICON;
     					break;
     				case ITopologyStatus.NOT_VALIDATED:
     					statusIcon = NOT_VALIDATED_TOC_ICON;
     					break;
     				case ITopologyStatus.VALIDATED_WITH_DIRTY_ZONES:
     					statusIcon = VALIDATED_WITH_DIRTY_ZONES_TOC_ICON;
     					break;
     				case ITopologyStatus.VALIDATED_WITH_ERRORS:
     					statusIcon = VALIDATED_WITH_ERRORS_TOC_ICON;
     					break;
     				case ITopologyStatus.VALIDATING:
     					statusIcon = VALIDATING_TOC_ICON;
     					break;
+    				}
     			}});
+    	}
     	public Topology(MapContext mapContext, FLayers layers){
     		this(mapContext, layers, 0d, 1000, new SimpleTopologyErrorContainer());
+    	}
     	public void addStatusListener(ITopologyStatusListener statusListener){
     		this.statusListeners.add(statusListener);
+    	}
     	/**
     	 * Creates a topology from its XML representation
     	 * @param xmlEntity
-...
     	public static Topology createFromXML(MapContext mapContext, XMLEntity xmlEntity){
     		FLayers rootLyr = mapContext.getLayers();
     		Topology solution = new Topology(mapContext, rootLyr);
     		try {
     			solution.setXMLEntity(xmlEntity);
     			if(solution.getErrorContainer() == null){
-...
+    		}
     		return solution;
+    	}
     	public ImageIcon getTocImageIcon() {
     		return statusIcon;
+    	}
     	public Image getTocStatusImage() {
     		return statusIcon.getImage();
+    	}
     	/**
     	 * Changes the cluster tolerance of the topology
+    	 *
+    	 *
+    	 *
+    	 *
     	 * This operation resets the status of the topology (it clears
     	 * errors and dirty zones)
+    	 *
+    	 *
     	 * @param clusterTolerance
     	 */
     	public void setClusterTolerance(double clusterTolerance) {
-...
     			MustBeLargerThanClusterTolerance rule = rulesIt.next();
     			rule.setClusterTolerance(clusterTolerance);
+    		}
+    	}
     	public double getClusterTolerance() {
     		return clusterTolerance;
+    	}
     	public void resetStatus(){
     		setStatus(NOT_VALIDATED);
     		this.clear();
     		this.dirtyZones.clear();
+    	}
     	/**
     	 * Adds a new topology rule to the topology.
+    	 *
+    	 *
     	 * The layers referenced by the rule must exist in the topology.
+    	 *
+    	 *
     	 * The state of the topology changes to "NON_VALIDATED", and a new dirty zone
     	 * is added for the scope of the new rule (envelope of one or two layers).
+    	 *
+    	 *
+    	 *
+    	 *
     	 * @throws TopologyRuleDefinitionException
     	 */
     	public void addRule(ITopologyRule rule) throws RuleNotAllowedException,
-...
     		if(status == VALIDATING)
     			throw new RuleNotAllowedException("No se puede a?adir una regla si la topologia est? siendo validada");
     		Rectangle2D ruleScope = null;
     		try {
     			if (rule instanceof IOneLyrRule) {
-...
     			e.printStackTrace();
     			throw new TopologyRuleDefinitionException(e);
+    		}
     		// before to add the rule we check if it verifies preconditions
     		rule.checkPreconditions();
     		rule.setTopology(this);
     		rules.add(rule);
     //   Si se a?ade una nueva regla, no es posible conservar los errores
     //   y las zonas sucias previas
     //		if(status == EMPTY)
-...
     		rule.setTopologyErrorContainer(this);
     		rule.setId(this.ruleId++);
+    	}
     	/*
     	 * Overwrited implementations of FLayers methods
     	 */
     	public void addLayer(FLayer layer) {
     		addLayer(layers.size(), layer);
+    	}
-...
     					"Intentando a?adir capa no vectorial a una topologia");
     		super.addLayer(pos, layer);
     		setRank((FLyrVect) layer, 1, 1);
     		int shapeType = -1;
     		try {
     			shapeType = ((FLyrVect)layer).getShapeType();
-...
     			e.printStackTrace();
     			throw new WrongLyrForTopologyException("Error al intentar verificar el tipo de geometria de la capa", e);
+    		}
     		MustBeLargerThanClusterTolerance rule = new
     		MustBeLargerThanClusterTolerance rule = new
     			MustBeLargerThanClusterTolerance(this, (FLyrVect) layer, clusterTolerance);
     		rule.setId(this.ruleId++);
     		Rectangle2D ruleScope;
-...
     			ruleScope = layer.getFullExtent();
     //		 before to add the rule we check if it verifies preconditions
     			rule.checkPreconditions();
     			if(status == EMPTY)
     				setStatus(NOT_VALIDATED);
     			else if(status == VALIDATED ){
-...
+    			}
     			rule.setTopologyErrorContainer(this);
     			clusterToleranceRules.add(rule);
     			//finally, we connect edition with topology
     			layer.addLayerListener(new LayerListener(){
-...
     				public void editionChanged(LayerEvent e) {
     					FLayer editionLyr = e.getSource();
     					if (editionLyr instanceof FLyrVect){
     						final ArrayList<Rectangle2D> dirtyZones = new ArrayList<Rectangle2D>();
     						FLyrVect fLyrVect = (FLyrVect)editionLyr;
     						ReadableVectorial rv = fLyrVect.getSource();
     						if(! (rv instanceof VectorialEditableAdapter))
     							return;
     						final VectorialEditableAdapter vea =
     							(VectorialEditableAdapter)rv;
     						vea.addEditionListener(new IEditionListener(){
     							public void afterFieldEditEvent(
-...
     								if(e.getChangeType() == EditionEvent.ALPHANUMERIC)
     									return;
     								int numRow = (int) e.getNumRow();
     								IGeometry geom;
     								try {
     									geom = vea.getShape(numRow);
-...
     				public void visibilityChanged(LayerEvent e) {
     				}});
     		} catch (ExpansionFileReadException e) {
     			e.printStackTrace();
     			throw new WrongLyrForTopologyException("No es posible acceder all FullExtent de la capa", e);
-...
     	/**
     	 * Sets the rank/importance of a layer in xy and z planes.
+    	 *
+    	 *
     	 * @param lyr layer
+    	 *
+    	 *
     	 * @param xyRank importance of this layer coordinates in xy plane
+    	 *
+    	 *
     	 * @param zRank importante of this layer coordinates in z plane
     	 */
     	public void setRank(FLyrVect lyr, int xyRank, int zRank) {
     		XYZLayerRank rank = new XYZLayerRank(lyr.getName(), xyRank, zRank);
     		layerRanks.put(lyr, rank);
+    	}
     	public XYZLayerRank getRank(FLyrVect lyr){
     		return layerRanks.get(lyr);
+    	}
-...
     		this.addLayer(layer);
     		setRank(layer, xyRank, zRank);
+    	}
     	/**
     	 * Remove a layer from a topology.
+    	 *
+    	 *
     	 * This task is more complex than removing a layer from a LayerCollection:
     	 * -must remove all rules which references to this layer.
     	 * -must recompute status and dirty zones.
     	 * etc.
+    	 *
+    	 *
     	 * TODO Implement remove layer as a geoprocess.
+    	 *
+    	 *
     	 */
     	public void removeLayer(FLayer lyr) throws CancelationException {
     		callLayerRemoving(LayerCollectionEvent.createLayerRemovingEvent(lyr));
     		//remove cluster rules related with the layer
     		Iterator<MustBeLargerThanClusterTolerance> clusterRulesIt = clusterToleranceRules.iterator();
     		while(clusterRulesIt.hasNext()){
-...
     				clusterRulesIt.remove();
+    			}
     		}//while
     		//Remove normal rules related with the layer
     		Iterator<ITopologyRule> rulesIt = this.rules.iterator();
     		while(rulesIt.hasNext()){
-...
     					continue;
+    				}
+    			}
     			if(rule instanceof ITwoLyrRule){
     				ITwoLyrRule twoLyrRule = (ITwoLyrRule) rule;
     				if(twoLyrRule.getOriginLyr().equals(lyr)){
-...
+    				}
+    			}
     		}//while
     		this.errorContainer.removeErrorsByLayer((FLyrVect) lyr);
     		this.layerRanks.remove(lyr);
     		this.layerRanks.remove(lyr);
     		this.updateDirtyZones();
     		callLayerRemoved(LayerCollectionEvent.createLayerRemovedEvent(lyr));
+    	}
     	public void removeLayer(int idLyr){
     		FLayer lyr = (FLayer) layers.get(idLyr);
     		removeLayer(lyr);
+    	}
     	public void removeRule(ITopologyRule rule){
     		if(rules.contains(rule)){
     			rules.remove(rule);
-...
     			clusterToleranceRules.remove(rule);
+    		}
     		this.errorContainer.removeErrorsByRule(rule.getName());
     		this.updateDirtyZones();
+    	}
     	private void updateDirtyZones() {
     //		this.dirtyZones.clear(); //FIXME REVISAR SI ES NECESARIO BORRAR LAS ZONAS SUCIAS
     		int errorNum = errorContainer.getNumberOfErrors();
-...
     	/**
     	 * Ranks (in xy plane and z plane) for layers of the topology.
+    	 *
+    	 *
     	 * The rank of layer marks its weight for computing weihgted average
     	 * coordinates.
+    	 *
+    	 *
     	 * @author azabala
+    	 *
+    	 *
     	 */
     	class XYZLayerRank implements IPersistence {
     		int xyRank;
-...
     			this.xyRank = xyRank;
     			this.zRank = zRank;
+    		}
     		XYZLayerRank(){}
     		public String getClassName() {
-...
     		public void setXMLEntity(XMLEntity xml) {
     			if(xml.contains("layerName"))
     				layerName = xml.getStringProperty("layerName");
     			if(xml.contains("xyRank"))
     				xyRank = xml.getIntProperty("xyRank");
     			if(xml.contains("zRank"))
     				zRank = xml.getIntProperty("zRank");
+    		}
+    	}
-...
     		newStatusEvent.prevStatus = this.status;
     		newStatusEvent.newStatus = newStatus;
     		this.status = newStatus;
     		fireStatusChange(newStatusEvent);
+    	}
     	public byte getStatus() {
     		return status;
+    	}
     	public List<ITopologyRule> getAllRules(){
     		List<ITopologyRule> solution = new ArrayList<ITopologyRule>();
     		solution.addAll(this.rules);
-...
     				return;
+    			}
     		}// while
     		if(status == VALIDATED)
     			setStatus(VALIDATED_WITH_DIRTY_ZONES);
     		// at this point, we add the new dirty zone
     		dirtyZones.add(newDirtyZone);
+    	}
     	public void removeDirtyZone(Rectangle2D newDirtyZone) {
     		if(status == NOT_VALIDATED)
     			return;//maybe we must launch an inconsistent status exception
-...
     		// at this point, we add the new dirty zone
     		dirtyZones.remove(newDirtyZone);
+    	}
     	public Rectangle2D getDirtyZone(int i) {
     		return dirtyZones.get(i);
+    	}
     	public int getNumberOfDirtyZones(){
     		return dirtyZones.size();
+    	}
     	public void validate(){
     		validate(null);
+    	}
     	/**
     	 * Validates the topology: it validates each topology rule for the given
     	 * dirty zones. After the end of the process,
     	 */
     	public void validate(CancellableProgressTask progressMonitor) {
     		if(progressMonitor != null){
     			progressMonitor.setInitialStep(0);
     			int numOfSteps = rules.size() + clusterToleranceRules.size();
-...
     			progressMonitor.setNote(Messages.getText("Validating_a_topology"));
     			progressMonitor.setStatusMessage(Messages.getText(rules.get(0).getName()));
+    		}
     		if (this.status == EMPTY) {
     			//TODO Maybe we must do progressMonitor.setFinished(true)
     			//or throw an exception
     			return;
     		} else if (this.status == VALIDATED) {
     			return;
+    		}
+    		}
     		else if (this.status == NOT_VALIDATED){
     			setStatus(VALIDATING);
     			//we make a local copy of dirty zones to avoid to use dirty zones created in
     			//we make a local copy of dirty zones to avoid to use dirty zones created in
     			//the current validation.
     			ArrayList<Rectangle2D> dirtyZonesCopy = new ArrayList<Rectangle2D>();
     			Collections.copy(dirtyZonesCopy, this.dirtyZones);
     			Iterator<MustBeLargerThanClusterTolerance> it =
     			Iterator<MustBeLargerThanClusterTolerance> it =
     				clusterToleranceRules.iterator();
     			while(it.hasNext()){
     				MustBeLargerThanClusterTolerance rule = it.next();
-...
        						Messages.getText(rule.getName()));
     					progressMonitor.reportStep();
+       				}
     				if(getNumberOfErrors() >= this.maxNumberOfErrors){
     					if(progressMonitor != null)
     						progressMonitor.setCanceled(true);
     					return;
+    				}
     				rule.checkRule(progressMonitor);
+    			}
     			Iterator<ITopologyRule> rulesIt = this.rules.iterator();
     			while (rulesIt.hasNext()) {
     				ITopologyRule rule = rulesIt.next();
     				if(progressMonitor != null){
     					if(progressMonitor.isCanceled()/*|| progressMonitor.isFinished()*/){
     						resetStatus();
-...
        						Messages.getText(rule.getName()));
     					progressMonitor.reportStep();
+       				}
     				if(getNumberOfErrors() >= this.maxNumberOfErrors){
     					if(progressMonitor != null)
     						progressMonitor.setCanceled(true);
     					return;
+    				}
     				if(dirtyZonesCopy.size() == 0){
     					rule.checkRule(progressMonitor);
     				}else{
     					//A topology is NON_VALIDATED with dirty zones when
     					//it has VALIDATED status and we add a new rule.
     					//TODO Check to add a new rule to a topology
     					//with VALIDATED_WITH_ERROR status
     					Iterator<Rectangle2D> dirtyZonesIt = dirtyZonesCopy.iterator();
-...
     				setStatus(VALIDATED_WITH_ERRORS);
     				addErrorLyr();
     			}else
     				setStatus(VALIDATED);
     				setStatus(VALIDATED);
+    		}
     		else if (this.status == VALIDATED_WITH_ERRORS ||
     		else if (this.status == VALIDATED_WITH_ERRORS ||
     				this.status == ITopologyStatus.VALIDATED_WITH_DIRTY_ZONES) {
     			setStatus(VALIDATING);
     			// this topology must have at least one dirty zone
-...
     			Iterator<Rectangle2D> dirtyZonesIt = this.dirtyZones.iterator();
     			while (dirtyZonesIt.hasNext()) {
     				Rectangle2D dirtyZone = dirtyZonesIt.next();
     				Iterator<MustBeLargerThanClusterTolerance> it = this.clusterToleranceRules.iterator();
     				while(it.hasNext()){
     					MustBeLargerThanClusterTolerance rule = it.next();
-...
     	   						Messages.getText(rule.getName()));
     						progressMonitor.reportStep();
+    	   				}
     					if(getNumberOfErrors() >= this.maxNumberOfErrors){
     						if(progressMonitor != null)
     							progressMonitor.setCanceled(true);
     						return;
+    					}
     					rule.checkRule(dirtyZone);
+    				}
     				Iterator<ITopologyRule> rulesIt = this.rules.iterator();
     				while (rulesIt.hasNext()) {
     					ITopologyRule rule = rulesIt.next();
-...
     	   						Messages.getText(rule.getName()));
     						progressMonitor.reportStep();
+    	   				}
     					if(getNumberOfErrors() >= this.maxNumberOfErrors){
     						if(progressMonitor != null)
     							progressMonitor.setCanceled(true);
-...
+    					}
     					rule.checkRule(dirtyZone);
     				}//while
     			}//while
     			if(this.errorContainer.getNumberOfErrors() > 0){
     				setStatus(VALIDATED_WITH_ERRORS);
-...
     		}//if
+    	}
     	private void addErrorLyr() {
     	private void addErrorLyr() {
     		IProjection proj = this.getProjection();
     		int idx = 0;
     		while(proj == null && idx < this.getLayerCount()){
-...
     	public int getLayerCount() {
     		return super.getLayersCount();
+    	}
     	public List getLayers(){
     		return this.layers;
+    	}
-...
     	public ITopologyRule getRule(int ruleIndex) {
     		return rules.get(ruleIndex);
+    	}
     	public ITopologyRule getRuleById(int ruleId){
     		for(int i = 0; i < rules.size(); i++){
     			ITopologyRule rule = rules.get(i);
-...
     				return rule;
     			}//if
     		}//for
     		for(int i = 0; i < clusterToleranceRules.size(); i++){
     			MustBeLargerThanClusterTolerance rule = clusterToleranceRules.get(i);
     			if(rule.getId() == ruleId){
-...
+    		}
     		return null;
+    	}
     	/**
     	 * Looks for all rules which has at least one reference to the given layer
     	 * (as origin or destination layer in the rule)
+    	 *
+    	 *
     	 * @param lyr
     	 * @return
     	 */
-...
     					continue;//dont need to check for destination layer
+    				}
     			}//if
     			if(rule instanceof ITwoLyrRule){
     				ITwoLyrRule twoLyrRule = (ITwoLyrRule) rule;
     				FLyrVect destinationLyr = twoLyrRule.getDestinationLyr();
-...
     					solution.add(rule);
+    				}
+    			}
     		}//while
     		Iterator<MustBeLargerThanClusterTolerance> clusterIt = clusterToleranceRules.iterator();
     		while(clusterIt.hasNext()){
     			MustBeLargerThanClusterTolerance rule = clusterIt.next();
-...
+    		}
     		return solution;
+    	}
     	/**
     	 * Returns if a specified rectangle touch one of the existing dirty zones.
     	 * If not, probably is needed to add to the dirty zones collection. If true,
-...
     	/**
     	 * Modify the dirty zone of the specified index
+    	 *
+    	 *
     	 * TODO Make thread safe ?
     	 */
     	public void updateDirtyZone(int dirtyZoneIndex, Rectangle2D dirtyZone) {
-...
+    	}
     	/**
     	 * marks topologyErrors as an exception (and removes its bounds of the
     	 * marks topologyErrors as an exception (and removes its bounds of the
     	 * dirty zones list)
     	 * @param topologyError error to mark as exceptions
     	 */
-...
     		errorContainer.markAsTopologyException(topologyError);
     		Rectangle2D rect = topologyError.getGeometry().getBounds2D();
     		removeDirtyZone(rect);
     		if(status == VALIDATED_WITH_DIRTY_ZONES){
     			if(dirtyZones.size() == 0)
     				setStatus(VALIDATED);
-...
     				setStatus(VALIDATED);
+    		}
+    	}
     	public void demoteToError(TopologyError topologyError) {
     		errorContainer.demoteToError(topologyError);
     		Rectangle2D rect = topologyError.getGeometry().getBounds2D();
-...
     			setStatus(VALIDATED_WITH_ERRORS);
+    	}
     	public List<TopologyError> getTopologyErrorsByLyr(FLyrVect layer,
     													IProjection desiredProjection,
     													IProjection desiredProjection,
     													boolean includeExceptions) {
     		return errorContainer.getTopologyErrorsByLyr(layer,
     										 desiredProjection,
     		return errorContainer.getTopologyErrorsByLyr(layer,
     										 desiredProjection,
     										 includeExceptions);
+    	}
     	public List<TopologyError> getTopologyErrorsByRule(String ruleName,
     			IProjection desiredProjection, boolean includeExceptions) {
     		return errorContainer.getTopologyErrorsByRule(ruleName,
     												desiredProjection,
     		return errorContainer.getTopologyErrorsByRule(ruleName,
     												desiredProjection,
     												includeExceptions);
+    	}
     	public List<TopologyError> getTopologyErrorsByShapeType(int shapeType,
     			IProjection desiredProjection, boolean includeExceptions) {
     		return errorContainer.getTopologyErrorsByShapeType(shapeType,
     													desiredProjection,
     													includeExceptions);
     		return errorContainer.getTopologyErrorsByShapeType(shapeType,
     													desiredProjection,
     													includeExceptions);
+    	}
     	/**
     	 * Get TopologyError filtered byte shapeType, sourte layer of the rule which
     	 * was violtated by this error.
-...
     			boolean includeExceptions) {
     		return errorContainer.getTopologyErrors(ruleName,
     												shapeType,
     												sourceLayer,
     												desiredProjection,
     												shapeType,
     												sourceLayer,
     												desiredProjection,
     												includeExceptions);
+    	}
     	/**
     	 * Return an unique identifier for the error saved in this
     	 * TopologyErrorContainer.
+    	 *
+    	 *
     	 * Until a new error would be added to this error container, it will
     	 * return always the same error fid.
     	 */
-...
     	public TopologyError getTopologyError(int index) {
     		return errorContainer.getTopologyError(index);
+    	}
     	public void clear() {
     		errorContainer.clear();
+    	}
     	public XMLEntity getXMLEntity() throws XMLException{
     		//Topology is a subclass of FLayers, so the call to super
     		//allows to persist layer status, toc information and layers
     		XMLEntity xml = super.getXMLEntity();
     		//Si no ponemos esto className ser? FLayerDefault, no??
     		xml.putProperty("className", this.getClass().getName());
     		xml.putProperty("name", name);
     		xml.putProperty("clusterTolerance", clusterTolerance);
     		xml.putProperty("status", status);
     		xml.putProperty("maxNumberOfErrors", maxNumberOfErrors);
     		int numberOfTopologyRules = rules.size();
     		xml.putProperty("numberOfTopologyRules", numberOfTopologyRules);
     		for(int i = 0; i < numberOfTopologyRules; i++){
     			ITopologyRule rule = rules.get(i);
     			xml.addChild(rule.getXMLEntity());
+    		}
     		int numberOfClusterRules = clusterToleranceRules.size();
     		xml.putProperty("numberOfClusterRules", numberOfClusterRules);
     		for(int i = 0; i < numberOfClusterRules; i++){
     			MustBeLargerThanClusterTolerance rule = clusterToleranceRules.get(i);
     			xml.addChild(rule.getXMLEntity());
+    		}
     		int numberOfDirtyZones = dirtyZones.size();
     		xml.putProperty("numberOfDirtyZones", numberOfDirtyZones);
     		for(int i = 0; i < numberOfDirtyZones; i++){
-...
     				dirtyZoneXML.putProperty("extent" + i + "X", rect.getX());
     				dirtyZoneXML.putProperty("extent" + i + "Y", rect.getY());
     				dirtyZoneXML.putProperty("extent" + i + "W", rect.getWidth());
     				dirtyZoneXML.putProperty("extent" + i + "H", rect.getHeight());
     				dirtyZoneXML.putProperty("extent" + i + "H", rect.getHeight());
     				xml.addChild(dirtyZoneXML);
     			}//if
     		}//for
     		XMLEntity errorContainerXML = errorContainer.getXMLEntity();
     		xml.addChild(errorContainerXML);
     		Collection<XYZLayerRank> ranksVal = layerRanks.values();
     		int numberOfRanks = ranksVal.size();
     		xml.putProperty("numberOfRanks", numberOfRanks);
-...
+    		}
     		return xml;
+    	}
     	public void setXMLEntity(XMLEntity xml) throws XMLException {
     		super.setXMLEntity(xml);
     		//FIXME Cambiar el uso de childrenCount por el empleo de propiedades
     		int numLayers = this.getLayersCount();
     		int numProperties = this.getExtendedProperties().size();
     		int childrenCount = numLayers + numProperties;
     		if(xml.contains("clusterTolerance"))
+    		{
     			this.clusterTolerance = xml.getDoubleProperty("clusterTolerance");
+    		}
     		if(xml.contains("name"))
+    		{
     			this.name = xml.getStringProperty("name");
+    		}
     		if(xml.contains("status"))
+    		{
     			this.status = (byte) xml.getIntProperty("status");
+    		}
     		if(xml.contains("maxNumberOfErrors"))
+    		{
     			this.maxNumberOfErrors =  xml.getIntProperty("maxNumberOfErrors");
+    		}
     		if(xml.contains("numberOfTopologyRules"))
+    		{
     			int numberOfTopologyRules =   xml.getIntProperty("numberOfTopologyRules");
-...
     				this.rules.add(rule);
+    			}
+    		}
     		if(xml.contains("numberOfClusterRules")){
     			int numberOfClusterRules = xml.getIntProperty("numberOfClusterRules");
     			for(int i = 0; i < numberOfClusterRules; i++){
-...
     				this.clusterToleranceRules.add(rule);
+    			}
+    		}
     		if(xml.contains("numberOfDirtyZones")){
     			int numberOfDirtyZones = xml.getIntProperty("numberOfDirtyZones");
     			for(int i = 0; i < numberOfDirtyZones; i++){
-...
     				double y = dirtyZoneXml.getDoubleProperty("extent"+i+"Y");
     				double w = dirtyZoneXml.getDoubleProperty("extent"+i+"W");
     				double h = dirtyZoneXml.getDoubleProperty("extent"+i+"H");
     				Rectangle2D.Double rect = new Rectangle2D.Double(x, y, w, h);
     				dirtyZones.add(rect);
+    			}
+    		}
     		XMLEntity errorContainerXML = xml.getChild(childrenCount++);
     		if(errorContainerXML != null)
+    		{
     			this.errorContainer = TopologyPersister.createErrorContainerFromXML(errorContainerXML);
+    		}
     		if(xml.contains("numberOfRanks")){
     			int numberOfRanks = xml.getIntProperty("numberOfRanks");
     			for(int i = 0; i < numberOfRanks; i++){
-...
     				XYZLayerRank rank = new XYZLayerRank();
     				rank.setXMLEntity(xmlRank);
+    			}
+    		}
+    		}
+    	}
     	public int getNumberOfExceptions() {
-...
     	public void setName(String name) {
     		this.name = name;
+    	}
     	public ITopologyErrorContainer getErrorContainer(){
     		return this.errorContainer;
+    	}
     	public FLayer getErrorLayer(){
     		return this.errorLayer;
+    	}
     	public void setErrorContainer(ITopologyErrorContainer errorContainer){
     		this.errorContainer = errorContainer;
     		this.errorContainer.setTopology(this);
+    	}
     	private void fireStatusChange(TopologyStatusEvent event){
     		Iterator<ITopologyStatusListener> it =
     		Iterator<ITopologyStatusListener> it =
     			this.statusListeners.iterator();
     		while(it.hasNext()){
     			ITopologyStatusListener listener = it.next();
-...
     	public void removeErrorsByRule(String ruleName) {
     		this.errorContainer.removeErrorsByRule(ruleName);
+    	}
     	public void setRules(List<ITopologyRule> rules){
     		this.rules = rules;
+    	}
     	public void setDirtyZones(List<Rectangle2D> dirtyZones){
     		this.dirtyZones = dirtyZones;
+    	}
     	public void setStatusListeners(List<ITopologyStatusListener> statusListeners){
     		this.statusListeners = statusListeners;
+    	}
     	public void setLayerRanks(Map<FLyrVect, XYZLayerRank> layerRanks){
     		this.layerRanks = layerRanks;
+    	}
     	public Object clone(){
     		Topology newTopology = new Topology(super.getMapContext(), super.getParentLayer());
     		newTopology.setName(this.name);
-...
     		newTopology.setErrorContainer((ITopologyErrorContainer) errorContainer.clone());
     		return newTopology;
+    	}
     	public static void copyProperties(Topology from, Topology to){
     		to.setName(from.name);
     		to.ruleId = from.ruleId;
-...
     		to.setErrorContainer(from.errorContainer);
     		to.setStatusListeners(from.statusListeners);
     		to.setLayerRanks(from.layerRanks);
     		List layers = from.layers;
     		to.layers = new ArrayList();
     		for(int i = 0; i < layers.size(); i++){
     			to.addLayer((FLayer) layers.get(i));
+    		}
     //		to.layers = from.layers;
+    	}
-...
     	/*
     	 * Implementation of ITopologyErrorContanier
+    	 *
+    	 *
     	 */
     	public Topology getTopology() {
     		return this;

Also available in: Unified diff