/ - Diff - Application: gvSIG desktop - gvSIG

Revision 19644

      */
     /* 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)
+     *
+     *
+     *
      * 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)
+     *
+     *
      * @author azabala
+     *
+     *
      */
     public class Topology extends FLayers implements ITopologyStatus, ITopologyErrorContainer, Cloneable {
     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 =
     		new ImageIcon(Topology.class.getResource("images/topoicon.png"));
     	private final static ImageIcon NOT_VALIDATED_TOC_ICON = new ImageIcon(
     			Topology.class.getResource("images/topoicon.png"));
     	private final static ImageIcon VALIDATED_TOC_ICON =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validated.png"));
     	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 =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validated_with_errors.png"));
     	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 =
     		new ImageIcon(Topology.class.getResource("images/topoicon_empty.png"));
     	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 =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validated_with_dirty_zones.png"));
     	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 =
     		new ImageIcon(Topology.class.getResource("images/topoicon_validating.png"));
     	private final static ImageIcon VALIDATING_TOC_ICON = new ImageIcon(
     			Topology.class.getResource("images/topoicon_validating.png"));
     	private ImageIcon statusIcon = EMPTY_TOC_ICON;
-...
     	 */
     	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
     	 */
-...
     	private ITopologyErrorContainer errorContainer;
     	/**
     	 * Collection of error layers created from topology errors in topology
     	 * error container.
     	 * Collection of error layers created from topology errors in topology error
     	 * container.
     	 */
     	private FLayer errorLayer;
-...
     	 */
     	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 int ruleId = 0;
     	/**
     	 * Interface for all of these classes interested in listening topology change status
     	 * events.
     	 * Interface for all of these classes interested in listening topology
     	 * change status events.
+    	 *
     	 * @author Alvaro Zabala
+    	 *
+    	 *
     	 */
     	public interface ITopologyStatusListener{
     	public interface ITopologyStatusListener {
     		public void statusChange(TopologyStatusEvent event);
+    	}
     	/**
     	 * Topology change status event. It contains old and new topology status.
+    	 *
     	 * @author Alvaro Zabala
+    	 *
+    	 *
     	 */
     	public class TopologyStatusEvent{
     	public class TopologyStatusEvent {
     		int newStatus;
     		int prevStatus;
+    	}
     	/**
     	 * Default constructor for a topology as a FLayers
+    	 *
+    	 *
     	 * @param fmap
     	 * @param parent
     	 */
     	public Topology(MapContext fmap,
     					FLayers parent,
     					double clusterTolerance,
     					int numberOfErrors,
     					ITopologyErrorContainer errorContainer) {
     	public Topology(MapContext fmap, FLayers parent, double clusterTolerance,
     			int numberOfErrors, ITopologyErrorContainer errorContainer) {
     		super.setMapContext(fmap);
     		super.setParentLayer(parent);
     		this.clusterTolerance = clusterTolerance;
-...
     		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(){
     		// This listener updates the icon status returneb by this kind of layer
     		statusListeners.add(new ITopologyStatusListener() {
     			public void statusChange(TopologyStatusEvent event) {
     				switch(event.newStatus){
     				switch (event.newStatus) {
     				case ITopologyStatus.VALIDATED:
     					statusIcon = VALIDATED_TOC_ICON;
     					break;
-...
     					statusIcon = VALIDATING_TOC_ICON;
     					break;
+    				}
     			}});
+    			}
     		});
+    	}
     	public Topology(MapContext mapContext, FLayers layers){
     	public Topology(MapContext mapContext, FLayers layers) {
     		this(mapContext, layers, 0d, 1000, new SimpleTopologyErrorContainer());
+    	}
     	public void addStatusListener(ITopologyStatusListener statusListener){
     	public void addStatusListener(ITopologyStatusListener statusListener) {
     		this.statusListeners.add(statusListener);
+    	}
     	/**
     	 * Creates a topology from its XML representation
+    	 *
     	 * @param xmlEntity
     	 * @return
     	 */
     	public static Topology createFromXML(MapContext mapContext, XMLEntity 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){
     			if (solution.getErrorContainer() == null) {
     				solution.setErrorContainer(new SimpleTopologyErrorContainer());
+    			}
     		} catch (XMLException e) {
     			logger.error("Error al reconstruir la topologia desde fichero xml", e);
     			logger.error("Error al reconstruir la topologia desde fichero xml",
     					e);
+    		}
     		return solution;
+    	}
-...
     	/**
     	 * Changes the cluster tolerance of the topology
+    	 *
+    	 *
     	 * This operation resets the status of the topology (it clears
     	 * errors and dirty zones)
+    	 *
+    	 *
+    	 *
     	 * This operation resets the status of the topology (it clears errors and
     	 * dirty zones)
+    	 *
     	 * @param clusterTolerance
     	 */
     	public void setClusterTolerance(double clusterTolerance) {
     		if(status == VALIDATING)
     			return;//maybe we could launch an exception??
     		if (status == VALIDATING)
     			return;// maybe we could launch an exception??
     		this.clusterTolerance = clusterTolerance;
     		resetStatus();
     		Iterator<MustBeLargerThanClusterTolerance> rulesIt = this.clusterToleranceRules.iterator();
     		while(rulesIt.hasNext()){
     		Iterator<MustBeLargerThanClusterTolerance> rulesIt = this.clusterToleranceRules
     				.iterator();
     		while (rulesIt.hasNext()) {
     			MustBeLargerThanClusterTolerance rule = rulesIt.next();
     			rule.setClusterTolerance(clusterTolerance);
+    		}
-...
     		return clusterTolerance;
+    	}
     	public void resetStatus(){
     	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).
+    	 *
+    	 *
+    	 *
     	 * 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,
     			TopologyRuleDefinitionException {
     		if(status == VALIDATING)
     			throw new RuleNotAllowedException("No se puede a?adir una regla si la topologia est? siendo validada");
     		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) {
-...
     		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)
     //			status = NOT_VALIDATED;
     //		else if(status == VALIDATED ){
     //			status = VALIDATED_WITH_DIRTY_ZONES;
     //			addDirtyZone(ruleScope);
     //		}else if(status == VALIDATED_WITH_ERRORS){
     //			//we dont change the status, but add a new dirty zone
     //			addDirtyZone(ruleScope);
     //		}
     		// Si se a?ade una nueva regla, no es posible conservar los errores
     		// y las zonas sucias previas
     		// if(status == EMPTY)
     		// status = NOT_VALIDATED;
     		// else if(status == VALIDATED ){
     		// status = VALIDATED_WITH_DIRTY_ZONES;
     		// addDirtyZone(ruleScope);
     		// }else if(status == VALIDATED_WITH_ERRORS){
     		// //we dont change the status, but add a new dirty zone
     		// addDirtyZone(ruleScope);
     		// }
     		resetStatus();
     		rule.setTopologyErrorContainer(this);
     		rule.setId(this.ruleId++);
+    	}
     	/*
     	 * Overwrited implementations of FLayers methods
     	 */
-...
     		addLayer(layers.size(), layer);
+    	}
     	public void addLayer(int pos, FLayer layer)  {
     	public void addLayer(int pos, FLayer layer) {
     		if (!(layer instanceof FLyrVect))
     			throw new WrongLyrForTopologyException(
     					"Intentando a?adir capa no vectorial a una topologia");
-...
     		int shapeType = -1;
     		try {
     			shapeType = ((FLyrVect)layer).getShapeType();
     			if( (shapeType == FShape.POINT) || (shapeType == FShape.MULTIPOINT) || (shapeType == FShape.TEXT))
     			shapeType = ((FLyrVect) layer).getShapeType();
     			if ((shapeType == FShape.POINT) || (shapeType == FShape.MULTIPOINT)
     					|| (shapeType == FShape.TEXT))
     				return;
     		} catch (ReadDriverException e) {
     			e.printStackTrace();
     			throw new WrongLyrForTopologyException("Error al intentar verificar el tipo de geometria de la capa", e);
     			throw new WrongLyrForTopologyException(
     					"Error al intentar verificar el tipo de geometria de la capa",
     					e);
+    		}
     		MustBeLargerThanClusterTolerance rule = new
     			MustBeLargerThanClusterTolerance(this, (FLyrVect) layer, clusterTolerance);
     		MustBeLargerThanClusterTolerance rule = new MustBeLargerThanClusterTolerance(
     				this, (FLyrVect) layer, clusterTolerance);
     		rule.setId(this.ruleId++);
     		Rectangle2D ruleScope;
     		try {
     			ruleScope = layer.getFullExtent();
     //		 before to add the rule we check if it verifies preconditions
     			// before to add the rule we check if it verifies preconditions
     			rule.checkPreconditions();
     			if(status == EMPTY)
     			if (status == EMPTY)
     				setStatus(NOT_VALIDATED);
     			else if(status == VALIDATED ){
     			else if (status == VALIDATED) {
     				setStatus(VALIDATED_WITH_DIRTY_ZONES);
     				addDirtyZone(ruleScope);
     			}else if(status == VALIDATED_WITH_ERRORS){
     				//we dont change the status, but add a new dirty zone
     //				addDirtyZone(ruleScope);
     				//si habia errores, la reevaluacion haria que se repitiesen
     			} else if (status == VALIDATED_WITH_ERRORS) {
     				// we dont change the status, but add a new dirty zone
     				// addDirtyZone(ruleScope);
     				// si habia errores, la reevaluacion haria que se repitiesen
     				resetStatus();
+    			}
     			rule.setTopologyErrorContainer(this);
     			clusterToleranceRules.add(rule);
     			//finally, we connect edition with topology
     			layer.addLayerListener(new LayerListener(){
     			// finally, we connect edition with topology
     			layer.addLayerListener(new LayerListener() {
     				public void activationChanged(LayerEvent e) {
+    				}
-...
     				public void editionChanged(LayerEvent e) {
     					FLayer editionLyr = e.getSource();
     					if (editionLyr instanceof FLyrVect){
     					if (editionLyr instanceof FLyrVect) {
     						final ArrayList<Rectangle2D> dirtyZones = new ArrayList<Rectangle2D>();
     						FLyrVect fLyrVect = (FLyrVect)editionLyr;
     						FLyrVect fLyrVect = (FLyrVect) editionLyr;
     						ReadableVectorial rv = fLyrVect.getSource();
     						if(! (rv instanceof VectorialEditableAdapter))
     						if (!(rv instanceof VectorialEditableAdapter))
     							return;
     						final VectorialEditableAdapter vea =
     							(VectorialEditableAdapter)rv;
     						final VectorialEditableAdapter vea = (VectorialEditableAdapter) rv;
     						vea.addEditionListener(new IEditionListener(){
     						vea.addEditionListener(new IEditionListener() {
     							public void afterFieldEditEvent(
     									AfterFieldEditEvent e) {
-...
     							public void afterRowEditEvent(IRow row,
     									AfterRowEditEvent e) {
     								//If we include alphanumeric rules to a topology as a
     								//integrity rule, we'll add a new dirty zone for this too
     								if(e.getChangeType() == EditionEvent.ALPHANUMERIC)
     								// If we include alphanumeric rules to a
     								// topology as a
     								// integrity rule, we'll add a new dirty zone
     								// for this too
     								if (e.getChangeType() == EditionEvent.ALPHANUMERIC)
     									return;
     								int numRow = (int) e.getNumRow();
-...
+    							}
     							public void processEvent(EditionEvent e) {
     								if(e.getChangeType() == EditionEvent.STOP_EDITION){
     									for(int i = 0; i < dirtyZones.size(); i++){
     										Rectangle2D dirtyZone = dirtyZones.get(i);
     								if (e.getChangeType() == EditionEvent.STOP_EDITION) {
     									for (int i = 0; i < dirtyZones.size(); i++) {
     										Rectangle2D dirtyZone = dirtyZones
     												.get(i);
     										Topology.this.addDirtyZone(dirtyZone);
     									}//for
     								}//if
     							}});
     									}// for
     								}// if
+    							}
     						});
+    					}
+    				}
-...
+    				}
     				public void visibilityChanged(LayerEvent e) {
     				}});
+    				}
     			});
     		} catch (ExpansionFileReadException e) {
     			e.printStackTrace();
     			throw new WrongLyrForTopologyException("No es posible acceder all FullExtent de la capa", e);
     			throw new WrongLyrForTopologyException(
     					"No es posible acceder all FullExtent de la capa", e);
     		} catch (ReadDriverException e) {
     			e.printStackTrace();
     			throw new WrongLyrForTopologyException("No es posible acceder all FullExtent de la capa", e);
     			throw new WrongLyrForTopologyException(
     					"No es posible acceder all FullExtent de la capa", e);
     		} catch (TopologyRuleDefinitionException e) {
     			e.printStackTrace();
     			throw new WrongLyrForTopologyException("Regla topologica mal definida", e);
     			throw new WrongLyrForTopologyException(
     					"Regla topologica mal definida", 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
+    	 *
     	 * @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){
     	public XYZLayerRank getRank(FLyrVect lyr) {
     		return layerRanks.get(lyr);
+    	}
-...
     		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.
+    	 *
     	 * -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()){
     		// remove cluster rules related with the layer
     		Iterator<MustBeLargerThanClusterTolerance> clusterRulesIt = clusterToleranceRules
     				.iterator();
     		while (clusterRulesIt.hasNext()) {
     			MustBeLargerThanClusterTolerance rule = clusterRulesIt.next();
     			if(rule.getOriginLyr().equals(lyr)){
     			if (rule.getOriginLyr().equals(lyr)) {
     				clusterRulesIt.remove();
+    			}
     		}//while
     		}// while
     		//Remove normal rules related with the layer
     		// Remove normal rules related with the layer
     		Iterator<ITopologyRule> rulesIt = this.rules.iterator();
     		while(rulesIt.hasNext()){
     			ITopologyRule rule =  rulesIt.next();
     			if(rule instanceof IOneLyrRule){
     		while (rulesIt.hasNext()) {
     			ITopologyRule rule = rulesIt.next();
     			if (rule instanceof IOneLyrRule) {
     				IOneLyrRule oneLyrRule = (IOneLyrRule) rule;
     				if(oneLyrRule.getOriginLyr().equals(lyr)){
     				if (oneLyrRule.getOriginLyr().equals(lyr)) {
     					rulesIt.remove();
     					continue;
+    				}
+    			}
     			if(rule instanceof ITwoLyrRule){
     			if (rule instanceof ITwoLyrRule) {
     				ITwoLyrRule twoLyrRule = (ITwoLyrRule) rule;
     				if(twoLyrRule.getOriginLyr().equals(lyr)){
     				if (twoLyrRule.getOriginLyr().equals(lyr)) {
     					rulesIt.remove();
+    				}
+    			}
     		}//while
     		}// while
     		this.errorContainer.removeErrorsByLayer((FLyrVect) lyr);
     		this.layerRanks.remove(lyr);
-...
     		callLayerRemoved(LayerCollectionEvent.createLayerRemovedEvent(lyr));
+    	}
     	public void removeLayer(int idLyr){
     	public void removeLayer(int idLyr) {
     		FLayer lyr = (FLayer) layers.get(idLyr);
     		removeLayer(lyr);
+    	}
     	public void removeRule(ITopologyRule rule){
     		if(rules.contains(rule)){
     	public void removeRule(ITopologyRule rule) {
     		if (rules.contains(rule)) {
     			rules.remove(rule);
     		}else if(clusterToleranceRules.contains(rule)){
     		} else if (clusterToleranceRules.contains(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
     		// this.dirtyZones.clear(); //FIXME REVISAR SI ES NECESARIO BORRAR LAS
     		// ZONAS SUCIAS
     		int errorNum = errorContainer.getNumberOfErrors();
     		for(int i = 0; i < errorNum; i++){
     		for (int i = 0; i < errorNum; i++) {
     			TopologyError topologyError = errorContainer.getTopologyError(i);
     			Rectangle2D rect = topologyError.getGeometry().getBounds2D();
     			addDirtyZone(rect);
-...
     	/**
     	 * 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.zRank = zRank;
+    		}
     		XYZLayerRank(){}
     		XYZLayerRank() {
+    		}
     		public String getClassName() {
     			return this.getClass().getName();
-...
+    		}
     		public void setXMLEntity(XMLEntity xml) {
     			if(xml.contains("layerName"))
     			if (xml.contains("layerName"))
     				layerName = xml.getStringProperty("layerName");
     			if(xml.contains("xyRank"))
     			if (xml.contains("xyRank"))
     				xyRank = xml.getIntProperty("xyRank");
     			if(xml.contains("zRank"))
     			if (xml.contains("zRank"))
     				zRank = xml.getIntProperty("zRank");
+    		}
-...
     		return status;
+    	}
     	public List<ITopologyRule> getAllRules(){
     	public List<ITopologyRule> getAllRules() {
     		List<ITopologyRule> solution = new ArrayList<ITopologyRule>();
     		solution.addAll(this.rules);
     		solution.addAll(this.clusterToleranceRules);
-...
     	 * the topology has been edited)
     	 */
     	public void addDirtyZone(Rectangle2D newDirtyZone) {
     		if(status == NOT_VALIDATED)
     		if (status == NOT_VALIDATED)
     			return;
     		Iterator<Rectangle2D> zonesIt = dirtyZones.iterator();
     		while (zonesIt.hasNext()) {
-...
+    			}
     		}// while
     		if(status == VALIDATED)
     		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
     		if (status == NOT_VALIDATED)
     			return;// maybe we must launch an inconsistent status exception
     		Iterator<Rectangle2D> zonesIt = dirtyZones.iterator();
     		while (zonesIt.hasNext()) {
     			Rectangle2D dirtyZone = zonesIt.next();
-...
     		dirtyZones.remove(newDirtyZone);
+    	}
     	public Rectangle2D getDirtyZone(int i) {
     		return dirtyZones.get(i);
+    	}
     	public int getNumberOfDirtyZones(){
     	public int getNumberOfDirtyZones() {
     		return dirtyZones.size();
+    	}
     	public void validate(){
     	public void validate() {
     		validate(null);
+    	}
-...
     	 */
     	public void validate(CancellableProgressTask progressMonitor) {
     		if(progressMonitor != null){
     		if (progressMonitor != null) {
     			progressMonitor.setInitialStep(0);
     			int numOfSteps = rules.size() + clusterToleranceRules.size();
     			progressMonitor.setFinalStep(numOfSteps);
     			progressMonitor.setDeterminatedProcess(true);
     			progressMonitor.setNote(Messages.getText("Validating_a_topology"));
     			progressMonitor.setStatusMessage(Messages.getText(rules.get(0).getName()));
     			progressMonitor.setStatusMessage(Messages.getText(rules.get(0)
     					.getName()));
+    		}
     		if (this.status == EMPTY) {
     			//TODO Maybe we must do progressMonitor.setFinished(true)
     			//or throw an exception
     			// 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){
     		else if (this.status == NOT_VALIDATED) {
     			setStatus(VALIDATING);
     			//we make a local copy of dirty zones to avoid to use dirty zones created in
     			//the current validation.
     			// 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 =
     				clusterToleranceRules.iterator();
     			while(it.hasNext()){
     			Iterator<MustBeLargerThanClusterTolerance> it = clusterToleranceRules
     					.iterator();
     			while (it.hasNext()) {
     				MustBeLargerThanClusterTolerance rule = it.next();
     				if(progressMonitor != null){
     					if(progressMonitor.isCanceled()/*|| progressMonitor.isFinished()*/){
     				if (progressMonitor != null) {
     					if (progressMonitor.isCanceled()/*
     													 * ||
     													 * progressMonitor.isFinished()
     													 */) {
     						resetStatus();
     						return;
+    					}
     					progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")+" "+
        						Messages.getText(rule.getName()));
     					progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")
     							+ " " + Messages.getText(rule.getName()));
     					progressMonitor.reportStep();
+       				}
+    				}
     				if(getNumberOfErrors() >= this.maxNumberOfErrors){
     					if(progressMonitor != null)
     				if (getNumberOfErrors() >= this.maxNumberOfErrors) {
     					if (progressMonitor != null)
     						progressMonitor.setCanceled(true);
     					return;
+    				}
-...
     			while (rulesIt.hasNext()) {
     				ITopologyRule rule = rulesIt.next();
     				if(progressMonitor != null){
     					if(progressMonitor.isCanceled()/*|| progressMonitor.isFinished()*/){
     				if (progressMonitor != null) {
     					if (progressMonitor.isCanceled()/*
     													 * ||
     													 * progressMonitor.isFinished()
     													 */) {
     						resetStatus();
     						return;
+    					}
     					progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")+" "+
        						Messages.getText(rule.getName()));
     					progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")
     							+ " " + Messages.getText(rule.getName()));
     					progressMonitor.reportStep();
+       				}
+    				}
     				if(getNumberOfErrors() >= this.maxNumberOfErrors){
     					if(progressMonitor != null)
     				if (getNumberOfErrors() >= this.maxNumberOfErrors) {
     					if (progressMonitor != null)
     						progressMonitor.setCanceled(true);
     					return;
+    				}
     				if(dirtyZonesCopy.size() == 0){
     				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.
     				} 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();
     					while(dirtyZonesIt.hasNext()){
     					// TODO Check to add a new rule to a topology
     					// with VALIDATED_WITH_ERROR status
     					Iterator<Rectangle2D> dirtyZonesIt = dirtyZonesCopy
     							.iterator();
     					while (dirtyZonesIt.hasNext()) {
     						Rectangle2D rect = dirtyZonesIt.next();
     						rule.checkRule(progressMonitor,rect);
     					}//while
     				}//else
     			}//while
     			if(this.errorContainer.getNumberOfErrors() > 0){
     						rule.checkRule(progressMonitor, rect);
     					}// while
     				}// else
     			}// while
     			if (this.errorContainer.getNumberOfErrors() > 0) {
     				setStatus(VALIDATED_WITH_ERRORS);
     				addErrorLyr();
     			}else
     			} else
     				setStatus(VALIDATED);
+    		}
     		else if (this.status == VALIDATED_WITH_ERRORS ||
     				this.status == ITopologyStatus.VALIDATED_WITH_DIRTY_ZONES) {
     		} 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
     			if (this.dirtyZones.size() < 1){
     //				 FIXME Deberiamos lanzar una
     			if (this.dirtyZones.size() < 1) {
     				// FIXME Deberiamos lanzar una
     				// InconsistentStatusException ??
     				return;
+    			}
     			Iterator<Rectangle2D> dirtyZonesIt = this.dirtyZones.iterator();
     			while (dirtyZonesIt.hasNext()) {
     				Rectangle2D dirtyZone = dirtyZonesIt.next();
     			this.errorContainer.clear();
     				Iterator<MustBeLargerThanClusterTolerance> it = this.clusterToleranceRules.iterator();
     				while(it.hasNext()){
     					MustBeLargerThanClusterTolerance rule = it.next();
     					if(progressMonitor != null){
     						if(progressMonitor.isCanceled()/*|| progressMonitor.isFinished()*/){
     							resetStatus();
     							return;
+    						}
     						progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")+" "+
     	   						Messages.getText(rule.getName()));
     						progressMonitor.reportStep();
+    	   				}
     					if(getNumberOfErrors() >= this.maxNumberOfErrors){
     						if(progressMonitor != null)
     							progressMonitor.setCanceled(true);
     			Iterator<MustBeLargerThanClusterTolerance> it = this.clusterToleranceRules
     					.iterator();
     			while (it.hasNext()) {
     				MustBeLargerThanClusterTolerance rule = it.next();
     				if (progressMonitor != null) {
     					if (progressMonitor.isCanceled()/*
     													 * ||
     													 * progressMonitor.isFinished()
     													 */) {
     						//TODO Si se cancela la validacion de una topologia con
     						//estado VALIDADO CON ERRORES, NO SE DEBE LLAMAR A RESETSTATUS!!!
     						//LO QUE HAY QUE HACER ES RESTAURAR EL ESTADO PREVIO
     						resetStatus();
     						return;
+    					}
     					progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")
     							+ " " + Messages.getText(rule.getName()));
     					progressMonitor.reportStep();
+    				}
     				if (getNumberOfErrors() >= this.maxNumberOfErrors) {
     					if (progressMonitor != null)
     						progressMonitor.setCanceled(true);
     					return;
+    				}
     				List<Rectangle2D> dirtyZonesCopy = new ArrayList<Rectangle2D>(
     						dirtyZones);
     				Iterator<Rectangle2D> dirtyZonesIt = dirtyZonesCopy.iterator();
     				while (dirtyZonesIt.hasNext()) {
     					Rectangle2D dirtyZone = dirtyZonesIt.next();
     					rule.checkRule(dirtyZone);
+    				}
     			}// MustBeGreaterThanClusterTolerance
     				Iterator<ITopologyRule> rulesIt = this.rules.iterator();
     				while (rulesIt.hasNext()) {
     					ITopologyRule rule = rulesIt.next();
     					if(progressMonitor != null){
     						if(progressMonitor.isCanceled()/*|| progressMonitor.isFinished()*/){
     							resetStatus();
     							return;
+    						}
     						progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")+" "+
     	   						Messages.getText(rule.getName()));
     						progressMonitor.reportStep();
+    	   				}
     					if(getNumberOfErrors() >= this.maxNumberOfErrors){
     						if(progressMonitor != null)
     							progressMonitor.setCanceled(true);
     			Iterator<ITopologyRule> rulesIt = this.rules.iterator();
     			while (rulesIt.hasNext()) {
     				ITopologyRule rule = rulesIt.next();
     				if (progressMonitor != null) {
     					if (progressMonitor.isCanceled()/*
     													 * ||
     													 * progressMonitor.isFinished()
     													 */) {
     						resetStatus();
     						return;
+    					}
     					progressMonitor.setNote(Messages.getText("VALIDANDO_REGLA")
     							+ " " + Messages.getText(rule.getName()));
     					progressMonitor.reportStep();
+    				}
     				if (getNumberOfErrors() >= this.maxNumberOfErrors) {
     					if (progressMonitor != null)
     						progressMonitor.setCanceled(true);
     					return;
+    				}
     				List<Rectangle2D> dirtyZonesCopy = new ArrayList<Rectangle2D>(
     						dirtyZones);
     				Iterator<Rectangle2D> dirtyZonesIt = dirtyZonesCopy.iterator();
     				while (dirtyZonesIt.hasNext()) {
     					Rectangle2D dirtyZone = dirtyZonesIt.next();
     					rule.checkRule(dirtyZone);
     				}//while
     			}//while
     			if(this.errorContainer.getNumberOfErrors() > 0){
+    				}
     			}// while
     			if (this.errorContainer.getNumberOfErrors() > 0) {
     				setStatus(VALIDATED_WITH_ERRORS);
     				addErrorLyr();
     			}else
     			} else
     				setStatus(VALIDATED);
     		}//if
     		}// if
+    	}
     	private void addErrorLyr() {
     		IProjection proj = this.getProjection();
     		int idx = 0;
     		while(proj == null && idx < this.getLayerCount()){
     		while (proj == null && idx < this.getLayerCount()) {
     			proj = this.getLayer(idx).getProjection();
     			idx++;
+    		}
     		errorLayer = this.errorContainer.getAsFMapLayer(this.name+"_error", 														proj);
     		errorLayer = this.errorContainer.getAsFMapLayer(this.name + "_error",
     				proj);
+    	}
     	public int getLayerCount() {
     		return super.getLayersCount();
+    	}
     	public List getLayers(){
     	public List getLayers() {
     		return this.layers;
+    	}
-...
     		return rules.get(ruleIndex);
+    	}
     	public ITopologyRule getRuleById(int ruleId){
     		for(int i = 0; i < rules.size(); i++){
     	public ITopologyRule getRuleById(int ruleId) {
     		for (int i = 0; i < rules.size(); i++) {
     			ITopologyRule rule = rules.get(i);
     			if(rule.getId() == ruleId){
     			if (rule.getId() == ruleId) {
     				return rule;
     			}//if
     		}//for
     			}// if
     		}// for
     		for(int i = 0; i < clusterToleranceRules.size(); i++){
     			MustBeLargerThanClusterTolerance rule = clusterToleranceRules.get(i);
     			if(rule.getId() == ruleId){
     		for (int i = 0; i < clusterToleranceRules.size(); i++) {
     			MustBeLargerThanClusterTolerance rule = clusterToleranceRules
     					.get(i);
     			if (rule.getId() == ruleId) {
     				return rule;
     			}//if
     			}// if
+    		}
     		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
     	 */
     	public List<ITopologyRule> getRulesByLyr(FLyrVect lyr){
     	public List<ITopologyRule> getRulesByLyr(FLyrVect lyr) {
     		List<ITopologyRule> solution = new ArrayList<ITopologyRule>();
     		Iterator<ITopologyRule> ruleIt = this.rules.iterator();
     		while(ruleIt.hasNext()){
     		while (ruleIt.hasNext()) {
     			ITopologyRule rule = ruleIt.next();
     			if(rule instanceof IOneLyrRule){
     			if (rule instanceof IOneLyrRule) {
     				IOneLyrRule oneLyrRule = (IOneLyrRule) rule;
     				FLyrVect originLyr = oneLyrRule.getOriginLyr();
     				if(originLyr.equals(lyr))
+    				{
     				if (originLyr.equals(lyr)) {
     					solution.add(rule);
     					continue;//dont need to check for destination layer
     					continue;// dont need to check for destination layer
+    				}
     			}//if
     			}// if
     			if(rule instanceof ITwoLyrRule){
     			if (rule instanceof ITwoLyrRule) {
     				ITwoLyrRule twoLyrRule = (ITwoLyrRule) rule;
     				FLyrVect destinationLyr = twoLyrRule.getDestinationLyr();
     				if(destinationLyr.equals(lyr)){
     				if (destinationLyr.equals(lyr)) {
     					solution.add(rule);
+    				}
+    			}
     		}//while
     		}// while
     		Iterator<MustBeLargerThanClusterTolerance> clusterIt = clusterToleranceRules.iterator();
     		while(clusterIt.hasNext()){
     		Iterator<MustBeLargerThanClusterTolerance> clusterIt = clusterToleranceRules
     				.iterator();
     		while (clusterIt.hasNext()) {
     			MustBeLargerThanClusterTolerance rule = clusterIt.next();
     			FLyrVect originLyr = rule.getOriginLyr();
     			if(originLyr.equals(lyr))
+    			{
     			if (originLyr.equals(lyr)) {
     				solution.add(rule);
     				continue;//dont need to check for destination layer
     				continue;// dont need to check for destination layer
+    			}
+    		}
     		return solution;
-...
     	/**
     	 * 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
     	 * dirty zones list)
     	 * @param topologyError error to mark as exceptions
     	 * marks topologyErrors as an exception (and removes its bounds of the dirty
     	 * zones list)
+    	 *
     	 * @param topologyError
     	 *            error to mark as exceptions
     	 */
     	public void markAsTopologyException(TopologyError topologyError) {
     		errorContainer.markAsTopologyException(topologyError);
     		Rectangle2D rect = topologyError.getGeometry().getBounds2D();
     		removeDirtyZone(rect);
     		if(status == VALIDATED_WITH_DIRTY_ZONES){
     			if(dirtyZones.size() == 0)
     		if (status == VALIDATED_WITH_DIRTY_ZONES) {
     			if (dirtyZones.size() == 0)
     				setStatus(VALIDATED);
     		}else if(status == VALIDATED_WITH_ERRORS){
     			if(getNumberOfErrors() == getNumberOfExceptions())
     		} else if (status == VALIDATED_WITH_ERRORS) {
     			if (getNumberOfErrors() == getNumberOfExceptions())
     				setStatus(VALIDATED);
+    		}
+    	}
-...
     		errorContainer.demoteToError(topologyError);
     		Rectangle2D rect = topologyError.getGeometry().getBounds2D();
     		addDirtyZone(rect);
     		if(getNumberOfErrors() > getNumberOfExceptions() )
     		if (getNumberOfErrors() > getNumberOfExceptions())
     			setStatus(VALIDATED_WITH_ERRORS);
+    	}
     	public List<TopologyError> getTopologyErrorsByLyr(FLyrVect layer,
     													IProjection desiredProjection,
     													boolean includeExceptions) {
     			IProjection desiredProjection, boolean includeExceptions) {
     		return errorContainer.getTopologyErrorsByLyr(layer,
     										 desiredProjection,
     										 includeExceptions);
     		return errorContainer.getTopologyErrorsByLyr(layer, desiredProjection,
     				includeExceptions);
+    	}
     	public List<TopologyError> getTopologyErrorsByRule(String ruleName,
     			IProjection desiredProjection, boolean includeExceptions) {
     		return errorContainer.getTopologyErrorsByRule(ruleName,
     												desiredProjection,
     												includeExceptions);
     				desiredProjection, includeExceptions);
+    	}
     	public List<TopologyError> getTopologyErrorsByShapeType(int shapeType,
     			IProjection desiredProjection, boolean includeExceptions) {
     		return errorContainer.getTopologyErrorsByShapeType(shapeType,
     													desiredProjection,
     													includeExceptions);
     				desiredProjection, includeExceptions);
+    	}
     	/**
     	 * Get TopologyError filtered byte shapeType, sourte layer of the rule which
     	 * was violtated by this error.
-...
     			int shapeType, FLyrVect sourceLayer, IProjection desiredProjection,
     			boolean includeExceptions) {
     		return errorContainer.getTopologyErrors(ruleName,
     												shapeType,
     												sourceLayer,
     												desiredProjection,
     												includeExceptions);
     		return errorContainer.getTopologyErrors(ruleName, 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.
+    	 *
     	 * Until a new error would be added to this error container, it will return
     	 * always the same error fid.
     	 */
     	public synchronized String getErrorFid() {
     		return errorContainer.getErrorFid();
-...
     		errorContainer.clear();
+    	}
     	public XMLEntity getXMLEntity() throws XMLException{
     	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
     		// 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??
     		// Si no ponemos esto className ser? FLayerDefault, no??
     		xml.putProperty("className", this.getClass().getName());
     		xml.putProperty("name", name);
     		xml.putProperty("clusterTolerance", clusterTolerance);
-...
     		int numberOfTopologyRules = rules.size();
     		xml.putProperty("numberOfTopologyRules", numberOfTopologyRules);
     		for(int i = 0; i < numberOfTopologyRules; i++){
     		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);
     		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++){
     		for (int i = 0; i < numberOfDirtyZones; i++) {
     			Rectangle2D rect = dirtyZones.get(i);
     			if(rect != null){
     			if (rect != null) {
     				XMLEntity dirtyZoneXML = new XMLEntity();
     				dirtyZoneXML.putProperty("extent" + i + "X", rect.getX());
     				dirtyZoneXML.putProperty("extent" + i + "Y", rect.getY());
-...
     				dirtyZoneXML.putProperty("extent" + i + "H", rect.getHeight());
     				xml.addChild(dirtyZoneXML);
     			}//if
     			}// if
     		}//for
     		}// for
     		XMLEntity errorContainerXML = errorContainer.getXMLEntity();
     		xml.addChild(errorContainerXML);
-...
     		int numberOfRanks = ranksVal.size();
     		xml.putProperty("numberOfRanks", numberOfRanks);
     		Iterator<XYZLayerRank> xyzRankIterator = layerRanks.values().iterator();
     		while(xyzRankIterator.hasNext()){
     		while (xyzRankIterator.hasNext()) {
     			XYZLayerRank layerRank = xyzRankIterator.next();
     			XMLEntity entity = layerRank.getXMLEntity();
     			xml.addChild(entity);
-...
     		return xml;
+    	}
     	public void setXMLEntity(XMLEntity xml) throws XMLException {
     		super.setXMLEntity(xml);
     		//FIXME Cambiar el uso de childrenCount por el empleo de propiedades
     		// 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"))
+    		{
     		if (xml.contains("clusterTolerance")) {
     			this.clusterTolerance = xml.getDoubleProperty("clusterTolerance");
+    		}
     		if(xml.contains("name"))
+    		{
     		if (xml.contains("name")) {
     			this.name = xml.getStringProperty("name");
+    		}
     		if(xml.contains("status"))
+    		{
     		if (xml.contains("status")) {
     			this.status = (byte) xml.getIntProperty("status");
+    		}
     		if(xml.contains("maxNumberOfErrors"))
+    		{
     			this.maxNumberOfErrors =  xml.getIntProperty("maxNumberOfErrors");
     		if (xml.contains("maxNumberOfErrors")) {
     			this.maxNumberOfErrors = xml.getIntProperty("maxNumberOfErrors");
+    		}
     		if(xml.contains("numberOfTopologyRules"))
+    		{
     			int numberOfTopologyRules =   xml.getIntProperty("numberOfTopologyRules");
     			for(int i = 0; i < numberOfTopologyRules; i++){
     		if (xml.contains("numberOfTopologyRules")) {
     			int numberOfTopologyRules = xml
     					.getIntProperty("numberOfTopologyRules");
     			for (int i = 0; i < numberOfTopologyRules; i++) {
     				XMLEntity ruleXML = xml.getChild(childrenCount++);
     				ITopologyRule rule = TopologyRuleFactory.createFromXML(this, ruleXML);
     				ITopologyRule rule = TopologyRuleFactory.createFromXML(this,
     						ruleXML);
     				this.rules.add(rule);
+    			}
+    		}
     		if(xml.contains("numberOfClusterRules")){
     			int numberOfClusterRules = xml.getIntProperty("numberOfClusterRules");
     			for(int i = 0; i < numberOfClusterRules; i++){
     		if (xml.contains("numberOfClusterRules")) {
     			int numberOfClusterRules = xml
     					.getIntProperty("numberOfClusterRules");
     			for (int i = 0; i < numberOfClusterRules; i++) {
     				XMLEntity ruleXML = xml.getChild(childrenCount++);
     				MustBeLargerThanClusterTolerance rule = (MustBeLargerThanClusterTolerance)TopologyRuleFactory.createFromXML(this, ruleXML);
     				MustBeLargerThanClusterTolerance rule = (MustBeLargerThanClusterTolerance) TopologyRuleFactory
     						.createFromXML(this, ruleXML);
     				this.clusterToleranceRules.add(rule);
+    			}
+    		}
     		if(xml.contains("numberOfDirtyZones")){
     		if (xml.contains("numberOfDirtyZones")) {
     			int numberOfDirtyZones = xml.getIntProperty("numberOfDirtyZones");
     			for(int i = 0; i < numberOfDirtyZones; i++){
     			for (int i = 0; i < numberOfDirtyZones; i++) {
     				XMLEntity dirtyZoneXml = xml.getChild(childrenCount++);
     				double x = dirtyZoneXml.getDoubleProperty("extent"+i+"X");
     				double y = dirtyZoneXml.getDoubleProperty("extent"+i+"Y");
     				double w = dirtyZoneXml.getDoubleProperty("extent"+i+"W");
     				double h = dirtyZoneXml.getDoubleProperty("extent"+i+"H");
     				double x = dirtyZoneXml.getDoubleProperty("extent" + i + "X");
     				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 (errorContainerXML != null) {
     			this.errorContainer = TopologyPersister
     					.createErrorContainerFromXML(errorContainerXML);
+    		}
     		if(xml.contains("numberOfRanks")){
     		if (xml.contains("numberOfRanks")) {
     			int numberOfRanks = xml.getIntProperty("numberOfRanks");
     			for(int i = 0; i < numberOfRanks; i++){
     			for (int i = 0; i < numberOfRanks; i++) {
     				XMLEntity xmlRank = xml.getChild(childrenCount++);
     				XYZLayerRank rank = new XYZLayerRank();
     				rank.setXMLEntity(xmlRank);
-...
     		return this.errorContainer.getNumberOfExceptions();
+    	}
     	public String getName() {
     		return name;
+    	}
     	public void setName(String name) {
     		this.name = name;
+    	}
     	public ITopologyErrorContainer getErrorContainer(){
     	public ITopologyErrorContainer getErrorContainer() {
     		return this.errorContainer;
+    	}
     	public FLayer getErrorLayer(){
     	public FLayer getErrorLayer() {
     		return this.errorLayer;
+    	}
     	public void setErrorContainer(ITopologyErrorContainer errorContainer){
     	public void setErrorContainer(ITopologyErrorContainer errorContainer) {
     		this.errorContainer = errorContainer;
     		this.errorContainer.setTopology(this);
+    	}
     	private void fireStatusChange(TopologyStatusEvent event){
     		Iterator<ITopologyStatusListener> it =
     			this.statusListeners.iterator();
     		while(it.hasNext()){
     	private void fireStatusChange(TopologyStatusEvent event) {
     		Iterator<ITopologyStatusListener> it = this.statusListeners.iterator();
     		while (it.hasNext()) {
     			ITopologyStatusListener listener = it.next();
     			listener.statusChange(event);
+    		}
-...
     		this.errorContainer.removeErrorsByRule(ruleName);
+    	}
     	public void setRules(List<ITopologyRule> rules){
     	public void setRules(List<ITopologyRule> rules) {
     		this.rules = rules;
+    	}
     	public void setDirtyZones(List<Rectangle2D> dirtyZones){
     	public void setDirtyZones(List<Rectangle2D> dirtyZones) {
     		this.dirtyZones = dirtyZones;
+    	}
     	public void setStatusListeners(List<ITopologyStatusListener> statusListeners){
     	public void setStatusListeners(List<ITopologyStatusListener> statusListeners) {
     		this.statusListeners = statusListeners;
+    	}
     	public void setLayerRanks(Map<FLyrVect, XYZLayerRank> layerRanks){
     	public void setLayerRanks(Map<FLyrVect, XYZLayerRank> layerRanks) {
     		this.layerRanks = layerRanks;
+    	}
     	public Object clone(){
     		Topology newTopology = new Topology(super.getMapContext(), super.getParentLayer());
     	public Object clone() {
     		Topology newTopology = new Topology(super.getMapContext(), super
     				.getParentLayer());
     		newTopology.setName(this.name);
     		newTopology.setClusterTolerance(this.clusterTolerance);
     		newTopology.ruleId = ruleId;
     		newTopology.setMaxNumberOfErrors(maxNumberOfErrors);
     		newTopology.setRules(rules)	;
     		newTopology.setRules(rules);
     		newTopology.setDirtyZones(dirtyZones);
     		newTopology.setStatusListeners(statusListeners);
     		newTopology.setLayerRanks(layerRanks);
     		newTopology.layers = new ArrayList();
     		for(int i = 0; i < layers.size(); i++){
     		for (int i = 0; i < layers.size(); i++) {
     			newTopology.addLayer((FLayer) layers.get(i));
+    		}
     		newTopology.setStatus(status);
     		newTopology.setErrorContainer((ITopologyErrorContainer) errorContainer.clone());
     		newTopology.setErrorContainer((ITopologyErrorContainer) errorContainer
     				.clone());

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff