/ - Diff - | gvSIG desktop 1 - gvSIG

Revision 24685

     		return null;
+    	}
     	public static ITopologyErrorContainer createErrorContainerFromXML(
     			XMLEntity xml) {
     	public static ITopologyErrorContainer createErrorContainerFromXML(Topology owner,
     																		XMLEntity xml) {
     		ITopologyErrorContainer solution = null;
     		String className = null;
     		if (xml.contains("className")) {
     			className = xml.getStringProperty("className");
     			Class clazz = null;
     			ITopologyErrorContainer obj = null;
     			try {
     				clazz = Class.forName(className);
     				obj = (ITopologyErrorContainer) clazz.newInstance();
     				obj.setXMLEntity(xml);
     				solution = (ITopologyErrorContainer) clazz.newInstance();
     				solution.setTopology(owner);
     				solution.setXMLEntity(xml);
     			} catch (Exception e) {
     				logger.error(e);
+    			}

     	public TopologyError(Topology parentTopology){
     		super(null, null, null);
     		this.topology = parentTopology;
+    	}
     	public void setViolatedRule(AbstractTopologyRule violatedRule) {
-...
     	public XMLEntity getXMLEntity() {
     		XMLEntity solution = FeatureUtil.getAsXmlEntity(this);
     		solution.putProperty("violatedRule", this.violatedRule.getId());
     		solution.putProperty("exception", this.exception);
     		solution.addChild(this.violatedRule.getXMLEntity());
     		XMLEntity xmlFeature = null;
     		boolean hasFeature1 = false;
     		if(feature1 != null){
     			FLyrVect originLyr = ((IOneLyrRule)violatedRule).getOriginLyr();
     			solution.putProperty("sourceLyr", originLyr.getName());
     			XMLEntity xmlFeature = FeatureUtil.getAsXmlEntity(feature1);
     			solution.putProperty("feature1", xmlFeature);
     			hasFeature1 = true;
     			xmlFeature = FeatureUtil.getAsXmlEntity(feature1);
     			solution.addChild(xmlFeature);
+    		}
     		solution.putProperty("hasFeature1", hasFeature1);
     		boolean hasFeature2 = false;
     		if(feature2 != null){
     			FLyrVect destinationLyr = ((ITwoLyrRule)violatedRule).getDestinationLyr();
     			solution.putProperty("sourceLyr", destinationLyr.getName());
     			XMLEntity xmlFeature = FeatureUtil.getAsXmlEntity(feature2);
     			solution.putProperty("feature2", xmlFeature);
     			hasFeature2 = true;
     			xmlFeature = FeatureUtil.getAsXmlEntity(feature2);
     			solution.addChild(xmlFeature);
+    		}
     		solution.putProperty("hasFeature2", hasFeature2);
     		return solution;
+    	}
-...
     		//first of all information xml of feature
     		FeatureUtil.setXMLEntity(this, xml);
     		if(xml.contains("violatedRule")){
     			int violatedRuleId = xml.getIntProperty("violatedRule");
     			violatedRule = topology.getRuleById(violatedRuleId);
+    		}
     		if(xml.contains("exception")){
     			exception = xml.getBooleanProperty("exception");
+    		}
     		if(xml.contains("feature1")){
     				XMLEntity entity = (XMLEntity) xml.getObjectProperty("feature1");
     				IFeature feature = FeatureUtil.getFeatureFromXmlEntity(entity);
     				feature1 = feature;
     		this.violatedRule =
     			 TopologyRuleFactory.createFromXML(this.topology, xml.getChild(0));
     		int childNumber = 1;
     		if(xml.contains("hasFeature1")){
     				boolean hasFeature1 = xml.getBooleanProperty("hasFeature1");
     				if(hasFeature1)
+    				{
     					this.feature1 = FeatureUtil.getFeatureFromXmlEntity(xml.getChild(childNumber));
     					childNumber++;
+    				}
     		}//if
     		if(xml.contains("feature2")){
     			XMLEntity entity = (XMLEntity) xml.getObjectProperty("feature2");
     			IFeature feature = FeatureUtil.getFeatureFromXmlEntity(entity);
     			feature2 = feature;
     		if(xml.contains("hasFeature2")){
     			boolean hasFeature2 = xml.getBooleanProperty("hasFeature2");
     			if(hasFeature2)
+    			{
     				this.feature2 = FeatureUtil.getFeatureFromXmlEntity(xml.getChild(childNumber));
+    			}
     		}//if
+    	}

     		xml.putProperty("className", getClassName());
     		xml.putProperty("originLayerName", this.originLyr.getName());
     		xml.putProperty("ruleId", this.ruleId);
     		if(this instanceof IRuleWithClusterTolerance){
     			double clusterTolerance = ((IRuleWithClusterTolerance)this).getClusterTolerance();
     			xml.putProperty("clusterTolerance", clusterTolerance);
+    		}
     		return xml;
+    	}
     	public void setXMLEntity(XMLEntity xml){
     		String originLayerName = "";
     		if (xml.contains("originLayer")) {
     			originLayerName = xml.getStringProperty("originLayer");
     		if (xml.contains("originLayerName")) {
     			originLayerName = xml.getStringProperty("originLayerName");
     			this.originLyr = (FLyrVect) topology.getLayer(originLayerName);
     		}//if
     		if(xml.contains("ruleId")){
     			ruleId = xml.getIntProperty("ruleId");
+    		}
     		if(xml.contains("clusterTolerance")){
     			double clusterTolerance = xml.getDoubleProperty("clusterTolerance");
     			if(this instanceof IRuleWithClusterTolerance)
     				((IRuleWithClusterTolerance)this).setClusterTolerance(clusterTolerance);
+    		}
+    	}
         public void setId(int ruleId){

     import com.iver.cit.gvsig.fmap.core.symbols.MultiShapeSymbol;
     import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     import com.iver.utiles.XMLEntity;
     import com.vividsolutions.jts.geom.Envelope;
     import com.vividsolutions.jts.geom.Geometry;
     import com.vividsolutions.jts.geom.Polygon;
-...
     		return automaticErrorFixes;
+    	}
     	public XMLEntity getXMLEntity(){
     		XMLEntity xml = super.getXMLEntity();
     		xml.putProperty("destinationLayerName", this.destinationLyr.getName());
     		return xml;
+    	}
     	@Override
     	public void setXMLEntity(XMLEntity xml){
     		super.setXMLEntity(xml);
     		String destinationLayerName = "";
     		if (xml.contains("destinationLayerName")) {
     			destinationLayerName = xml.getStringProperty("destinationLayerName");
     			this.destinationLyr = (FLyrVect) topology.getLayer(destinationLayerName);
     		}//if
+    	}
     	@Override
     	protected void process(IGeometry geometry, IFeature feature) {
     		Geometry jtsGeom = NewFConverter.toJtsGeometry(geometry);

     import com.iver.cit.gvsig.fmap.core.symbols.MultiShapeSymbol;
     import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     import com.iver.utiles.XMLEntity;
     import com.vividsolutions.jts.geom.Geometry;
     public abstract class AbstractSpatialPredicateTwoLyrRule extends AbstractTopologyRule implements ITwoLyrRule {
-...
+    	}
     	/**
     	 * Constructor without topology param
+    	 *
     	 * @param originLyr
     	 */
     	public AbstractSpatialPredicateTwoLyrRule(FLyrVect originLyr, FLyrVect destinationLyr){
     		this(null, originLyr, destinationLyr);
+    	}
     	public AbstractSpatialPredicateTwoLyrRule(){
     		super();
+    	}
-...
     		this.destinationLyr = destinationLyr;
+    	}
     	public XMLEntity getXMLEntity(){
     		XMLEntity xml = super.getXMLEntity();
     		xml.putProperty("destinationLayerName", this.destinationLyr.getName());
     		return xml;
+    	}
     	public void setXMLEntity(XMLEntity xml){
     		super.setXMLEntity(xml);
     		String destinationLayerName = "";
     		if (xml.contains("destinationLayerName")) {
     			destinationLayerName = xml.getStringProperty("destinationLayerName");
     			this.destinationLyr = (FLyrVect) topology.getLayer(destinationLayerName);
     		}//if
+    	}
     	protected TopologyError createTopologyError(Geometry errorGeometry,
     												IFeature feature,
     												IFeature neighbour){

     	 * 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;
     //	private Map<FLyrVect, XYZLayerRank> layerRanks;
     	/**
     	 * Numerical identifier for rules of a topology
-...
     		rules = new ArrayList<ITopologyRule>();
     		clusterToleranceRules = new ArrayList<MustBeLargerThanClusterTolerance>();
     		dirtyZones = new ArrayList<Rectangle2D>();
     		layerRanks = new HashMap<FLyrVect, XYZLayerRank>();
     //		layerRanks = new HashMap<FLyrVect, XYZLayerRank>();
     		statusListeners = new ArrayList<ITopologyStatusListener>();
     		// This listener updates the icon status returneb by this kind of layer
-...
     		super.addLayer(pos, layer);
     		setRank((FLyrVect) layer, 1, 1);
     //		setRank((FLyrVect) layer, 1, 1);
     		int shapeType = -1;
     		try {
-...
     	 * @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 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);
+    	}
     //	public XYZLayerRank getRank(FLyrVect lyr) {
     //		return layerRanks.get(lyr);
     //	}
     	/**
     	 * Adds a layer to the topology. If the topology has been validated, changes
-...
     	 */
     	public void addLayer(FLyrVect layer, int xyRank, int zRank) {
     		this.addLayer(layer);
     		setRank(layer, xyRank, zRank);
     //		setRank(layer, xyRank, zRank);
+    	}
     	/**
-...
     		}// while
     		this.errorContainer.removeErrorsByLayer((FLyrVect) lyr);
     		this.layerRanks.remove(lyr);
     //		this.layerRanks.remove(lyr);
     		this.updateDirtyZones();
     		callLayerRemoved(LayerCollectionEvent.createLayerRemovedEvent(lyr));
+    	}
-...
+    	}
     	public XMLEntity getXMLEntity() throws XMLException {
     		boolean errorLayerExists = this.errorLayer != null;
     		FLayer errorLayerCopy = null;
     		if(errorLayerExists){
     			errorLayerCopy = this.errorLayer;
     			super.removeLayer(this.errorLayer);
+    		}
     		// Topology is a subclass of FLayers, so the call to super
     		// allows to persist layer status, toc information and layers
     		XMLEntity xml = super.getXMLEntity();
-...
     			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 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);
-...
     		XMLEntity errorContainerXML = errorContainer.getXMLEntity();
     		xml.addChild(errorContainerXML);
     		xml.putProperty("errorLayerExists", errorLayerExists);
     		xml.putProperty("nextRuleFid", ruleId);
     		if(errorLayerExists){
     			this.errorLayer = errorLayerCopy;
     			try {
     				if(((FLyrVect)errorLayer).getSource().getShapeCount() > 0)
     					super.addLayer(this.layers.size(), this.errorLayer);
     			} catch (ReadDriverException e) {
     				e.printStackTrace();
+    			}
+    		}
     		Collection<XYZLayerRank> ranksVal = layerRanks.values();
     		int numberOfRanks = ranksVal.size();
     		xml.putProperty("numberOfRanks", numberOfRanks);
     		Iterator<XYZLayerRank> xyzRankIterator = layerRanks.values().iterator();
     		while (xyzRankIterator.hasNext()) {
     			XYZLayerRank layerRank = xyzRankIterator.next();
     			XMLEntity entity = layerRank.getXMLEntity();
     			xml.addChild(entity);
+    		}
     //		Collection<XYZLayerRank> ranksVal = layerRanks.values();
     //		int numberOfRanks = ranksVal.size();
     //		xml.putProperty("numberOfRanks", numberOfRanks);
     //		Iterator<XYZLayerRank> xyzRankIterator = layerRanks.values().iterator();
     //		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
     		int numLayers = this.getLayersCount();
     		int numProperties = this.getExtendedProperties().size();
-...
+    		}
     		if (xml.contains("status")) {
     			this.status = (byte) xml.getIntProperty("status");
     			int newStatus = xml.getIntProperty("status");
     			this.setStatus((byte) newStatus);
+    		}
     		if (xml.contains("maxNumberOfErrors")) {
     			this.maxNumberOfErrors = xml.getIntProperty("maxNumberOfErrors");
+    		}
     		if (xml.contains("nextRuleFid")) {
     			this.ruleId = xml.getIntProperty("nextRuleFid");
+    		}
     		boolean errorLayerExists = false;
     		if (xml.contains("errorLayerExists")) {
     			errorLayerExists = xml.getBooleanProperty("errorLayerExists");
+    		}
     		if (xml.contains("numberOfTopologyRules")) {
     			int numberOfTopologyRules = xml
     					.getIntProperty("numberOfTopologyRules");
-...
     				XMLEntity ruleXML = xml.getChild(childrenCount++);
     				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++) {
     				XMLEntity ruleXML = xml.getChild(childrenCount++);
     				MustBeLargerThanClusterTolerance rule = (MustBeLargerThanClusterTolerance) TopologyRuleFactory
     						.createFromXML(this, ruleXML);
     				this.clusterToleranceRules.add(rule);
+    			}
+    		}
     //		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);
     //				this.clusterToleranceRules.add(rule);
     //			}
     //		}
     		if (xml.contains("numberOfDirtyZones")) {
     			int numberOfDirtyZones = xml.getIntProperty("numberOfDirtyZones");
-...
     		XMLEntity errorContainerXML = xml.getChild(childrenCount++);
     		if (errorContainerXML != null) {
     			this.errorContainer = TopologyPersister
     					.createErrorContainerFromXML(errorContainerXML);
     					.createErrorContainerFromXML(this, errorContainerXML);
     			if(errorLayerExists)
+    			{
     				setErrorLyr();
     				updateErrorLyr();
+    			}
+    		}
     		if (xml.contains("numberOfRanks")) {
     			int numberOfRanks = xml.getIntProperty("numberOfRanks");
     			for (int i = 0; i < numberOfRanks; i++) {
     				XMLEntity xmlRank = xml.getChild(childrenCount++);
     				XYZLayerRank rank = new XYZLayerRank();
     				rank.setXMLEntity(xmlRank);
+    			}
+    		}
     //		if (xml.contains("numberOfRanks")) {
     //			int numberOfRanks = xml.getIntProperty("numberOfRanks");
     //			for (int i = 0; i < numberOfRanks; i++) {
     //				XMLEntity xmlRank = xml.getChild(childrenCount++);
     //				XYZLayerRank rank = new XYZLayerRank();
     //				rank.setXMLEntity(xmlRank);
     //			}
     //		}
+    	}
     	public int getNumberOfExceptions() {
-...
     		this.statusListeners = statusListeners;
+    	}
     	public void setLayerRanks(Map<FLyrVect, XYZLayerRank> layerRanks) {
     		this.layerRanks = layerRanks;
+    	}
     //	public void setLayerRanks(Map<FLyrVect, XYZLayerRank> layerRanks) {
     //		this.layerRanks = layerRanks;
     //	}
     	public Object clone() {
     		Topology newTopology = new Topology(super.getMapContext(), super
-...
     //		to.setStatusListeners(from.statusListeners);
     		to.setLayerRanks(from.layerRanks);
     //		to.setLayerRanks(from.layerRanks);
     		to.ruleId = from.ruleId;
-...
     	public void removeError(TopologyError topologyError) {
     		this.errorContainer.removeError(topologyError);
     		Rectangle2D rect = topologyError.getGeometry().getBounds2D();
     		removeDirtyZone(rect);
     		if (status == VALIDATED_WITH_DIRTY_ZONES) {
     			if (dirtyZones.size() == 0)
     				setStatus(VALIDATED);
     		} else if (status == VALIDATED_WITH_ERRORS) {
     			if (getNumberOfErrors() == getNumberOfExceptions() || getNumberOfErrors() == 0)
     				setStatus(VALIDATED);
+    		}
+    	}
     	public List<LayerCollectionListener> getLayerCollectionListeners(){

     		return solution;
+    	}
     	private static IGeometry geometryFromXmlByteArray(String xmlByteArray){
     		String[] bytes = xmlByteArray.split(",");
     		byte[] wkbErrorGeometry = new byte[bytes.length];
     		for(int i = 0; i < bytes.length; i++){
     			wkbErrorGeometry[i] = new Byte(bytes[i].trim()).byteValue();
+    		}
     		return wkbParser.parse(wkbErrorGeometry);
+    	}
     	public static void setXMLEntity(IFeature feature, XMLEntity xml){
     		if(xml.contains("fid")){
     			feature.setID(xml.getStringProperty("fid"));
+    		}
     		if(xml.contains("geometry")){
     			byte[] wkbErrorGeometry = (byte[]) xml.getObjectProperty("geometry");
     			feature.setGeometry( wkbParser.parse(wkbErrorGeometry) );
     			String xmlByteArray = (String) xml.getObjectProperty("geometry");
     			feature.setGeometry( geometryFromXmlByteArray(xmlByteArray) );
+    		}
     		if(xml.contains("numberOfAttributes")){
-...
+    		}
     		if(xml.contains("geometry")){
     			byte[] wkbErrorGeometry = (byte[]) xml.getObjectProperty("geometry");
     			geometry = wkbParser.parse(wkbErrorGeometry);
     			String xmlByteArray = (String) xml.getObjectProperty("geometry");
     			geometry = geometryFromXmlByteArray(xmlByteArray);
+    		}
     		if(xml.contains("numberOfAttributes")){

Also available in: Unified diff