/ - Diff - | gvSIG desktop 1 - gvSIG

     <?xml version="1.0" encoding="UTF-8"?>
     <classpath>
     	<classpathentry kind="src" path="src"/>
     	<classpathentry kind="src" output="bin-test" path="src-test"/>
     	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
     	<classpathentry kind="output" path="bin"/>
     </classpath>

     package org.gvsig.topology;
     /**
      *Marker interface for all rules that applies to two layers
      */
     public interface ITwoLyrRule extends ITopologyRule {
+    }

     package org.gvsig.topology;
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     import org.cresques.cts.IProjection;
     /**
      *All the classes that contains TopologyError must
      *implement this interface.
      */
     public interface ITopologyErrorContainer {
     	public static final int ONLY_ERRORS = 0;
     	public static final int ONLY_EXCEPTIONS = 1;
     	public static final int BOTH_ERROR_EXCEPTIONS = 2;
     	public void addTopologyError(TopologyError topologyError);
     	/**
     	 *Returns the errors contained. In function
     	 *of the specified params, returned errors
     	 *will be reprojected, filtered by rule, geometry type,
     	 *etc.
     	 */
     	public TopologyError[] getTopologyErrors(String ruleName, int shapeType, FLyrVect sourceLayer, IProjection desiredProjection, int includeExceptions);
     	/**
     	 *Marks the specified feature as the
     	 *specified status (exception or not exception)
     	 */
     	public void markAsTopologyException(TopologyError topologyError, boolean markAsException);
+    }

     package org.gvsig.topology;
     import com.iver.cit.gvsig.fmap.core.IFeature;
     /**
      *Error produced when one or many features ?
      *violates a topology rule.
      */
     public class TopologyError implements IFeature {
     	/**
     	 *rule which has been violated
     	 */
     	private AbstractTopologyRule violatedRule;
     	/**
     	 *features of the source layer that
     	 *violates the rule (if the rule is a self-rule,
     	 *the error will only have source layer features)
     	 */
     	private IFeature[] sourceLyrFeatures;
     	/**
     	 *features of the destination layer
     	 *that violate the rule (only in rules between
     	 *two layers)
     	 */
     	private IFeature[] destinationLyrFeatures;
     	private boolean exception;
     	public void setViolatedRule(AbstractTopologyRule violatedRule) {
+    	}
     	public AbstractTopologyRule getViolatedRule() {
     		return null;
+    	}
     	public void setSourceLyrFeatures(IFeature[] sourceLyrFeatures) {
+    	}
     	public IFeature[] getSourceLyrFeatures() {
     		return null;
+    	}
     	public void setDestinationLyrFeatures(IFeature[] destinationLyrFeatures) {
+    	}
     	public IFeature[] getDestinationLyrFeatures() {
     		return null;
+    	}
     	/**
     	 *Ruturns the type of geometry of the error
     	 */
     	public int getShapeType() {
     		return 0;
+    	}
     	public void setException(boolean exception) {
+    	}
     	public boolean isException() {
     		return false;
+    	}
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.IOneLyrRule;
     /**
      *All end points of a line must touch at least another line.
      *(if only touch one line, its a pseudonode, not a dangle)
      *This rule is checked for the two ends of a line.
+     *
      */
     public class LineMustNotHaveDangles extends AbstractTopologyRule implements IOneLyrRule {
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.IOneLyrRule;
     /**
      *This rule checks that a geometry (line or polygon)
      *dont have consecutive repeated points)
+     *
      */
     public class MustNotHaveRepeatedPoints extends AbstractTopologyRule implements IOneLyrRule {
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.IOneLyrRule;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.Topology;
     /**
      *For lines o polygons. The lenght of a line or the perimeter
      *of a polygon must be larger than the cluster tolerance
+     *
      */
     public class MustBeLargerThanClusterTolerance extends AbstractTopologyRule implements IOneLyrRule {
     	private Topology topology;
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.IOneLyrRule;
     /**
      *Any validated geometry must be a right JTS geometry.
      */
     public class JtsValidRule extends AbstractTopologyRule implements IOneLyrRule {
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.IOneLyrRule;
     /**
      *Lines of a layer must not have self intersections.
      *JTS allows this. This is one of the restrictions that must
      *not have pseudonodos checks.
+     *
      */
     public class LineMustNotSelfIntersect extends AbstractTopologyRule implements IOneLyrRule {
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.IOneLyrRule;
     /**
      *The polygons of a layer must not have self intersections
+     *
      */
     public class PolygonMustNotSelfIntersect extends AbstractTopologyRule implements IOneLyrRule {
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.IOneLyrRule;
     /**
      *The polygons of a given layer must not overlaps
      *each other (their intersection must be a line, not an area)
+     *
      */
     public class PolygonsMustNotOverlap extends AbstractTopologyRule implements IOneLyrRule {
+    }

     package org.gvsig.topology.topologyrules;
     import org.gvsig.topology.AbstractTopologyRule;
     import org.gvsig.topology.IOneLyrRule;
     /**
      *This rule checks that lines of a line layer dont have
      *pseudonodes ends (a point that only touch another line)
      */
     public class LinesMustNotHavePseudonodes extends AbstractTopologyRule implements IOneLyrRule {
+    }

     package org.gvsig.topology;
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     import com.iver.cit.gvsig.fmap.core.IFeature;
     import java.awt.geom.Rectangle2D;
     import java.util.Collection;
     public abstract class AbstractTopologyRule implements ITopologyRule {
     	private FLyrVect originLyr;
     	private FLyrVect destinationLyr;
     	private Topology topology;
     	public void setOriginLyr(FLyrVect originLyr) {
+    	}
     	public FLyrVect getOriginLyr() {
     		return null;
+    	}
     	public void setDestinationLyr(FLyrVect destinationLyr) {
+    	}
     	public FLyrVect getDestinationLyr() {
     		return null;
+    	}
     	public String getName() {
     		return null;
+    	}
     	/**
     	 *Checks if the rule's parameters
     	 *(sourceLyr, destinationLyr) verify
     	 *rule preconditions (geometry type, etc.)
     	 */
     	public void checkPreconditions() {
+    	}
     	public void checkRule() {
+    	}
     	void validateFeature(IFeature feature) {
+    	}
     	public void checkRule(Rectangle2D rect) {
+    	}
     	public Collection getTopologyErrors() {
     		return null;
+    	}
+    }

     package org.gvsig.topology;
     /**
      *Marker interface for all rules that applies to only one layer
+     *
      */
     public interface IOneLyrRule extends ITopologyRule {
+    }

     package org.gvsig.topology;
     public interface ITopologyStatus {
     	public static final byte VALIDATED = 0;
     	public static final byte VALIDATED_WITH_ERRORS = 1;
     	public static final byte NON_VALIDATED = 2;
+    }

     package org.gvsig.topology;
     import com.iver.cit.gvsig.fmap.layers.FLayers;
     import com.vividsolutions.jts.geom.Envelope;
     import java.awt.geom.Rectangle2D;
     import org.gvsig.topology.topologyrules.MustBeLargerThanClusterTolerance;
     import com.iver.cit.gvsig.fmap.layers.FLyrVect;
     public class Topology extends FLayers implements ITopologyErrorContainer, ITopologyStatus {
     	private double clusterTolerance;
     	private int status;
     	/**
     	 *If during validation process a topoly
     	 *exceeds this parameters, validation will be stopped.
+    	 *
     	 */
     	private int maxNumberOfErrors = -1;
     	private AbstractTopologyRule[] abstractTopologyRule;
     	private Envelope[] envelope;
     	private Rectangle2D[] dirtyZones;
     	private MustBeLargerThanClusterTolerance[] clusterTolRule;
     	public double getClusterTolerance() {
     		return 0;
+    	}
     	/**
     	 *Adds a new topology rule to the topology.
     	 */
     	public void addRule(AbstractTopologyRule rule) {
+    	}
     	/**
     	 *Adds a layer to the topology. If the topology has been validated, changes
     	 *topology status to NON-VALIDATED and adds a dirty zone equals to
     	 *the layer extent.
     	 */
     	public void addLayer(FLyrVect layer, int xyRank, int zRank) {
+    	}
     	public void setStatus(int status) {
+    	}
     	public int getStatus() {
     		return 0;
+    	}
     	/**
     	 *Adds a dirty zone to the topology
     	 *(usually whe a feature of a layer
     	 *of the topology has been edited)
     	 */
     	public void addDirtyZone(Rectangle2D dirtyZone) {
+    	}
     	public Rectangle2D getDirtyZone() {
     		return null;
+    	}
     	public void validate() {
+    	}
     	public int getLayerCount() {
     		return 0;
+    	}
     	public int getRuleCount() {
     		return 0;
+    	}
     	public FLyrVect getLyr(int lyrIndex) {
     		return null;
+    	}
     	public AbstractTopologyRule getRule(int ruleIndex) {
     		return null;
+    	}
     	/**
     	 *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, maybe it could modify the dirty zone.
     	 */
     	public boolean isInDirtyZone() {
     		return false;
+    	}
     	/**
     	 *Modify the dirty zone of the specified index
     	 */
     	public void updateDirtyZone(int dirtyZoneIndex, Rectangle2D dirtyZone) {
+    	}
     	public void setMaxNumberOfErrors(int maxNumberOfErrors) {
+    	}
     	public int getMaxNumberOfErrors() {
     		return 0;
+    	}
+    }

trunk/libraries/libTopology/uml-jude/org/gvsig/topology/ITopologyRule.java
	1	package org.gvsig.topology;
	2
	3	public interface ITopologyRule {
	4
	5	}
	6
0	7

     package org.gvsig.topology;
     import java.util.Map;
     /**
      *Class with the responsability of persist topologies
      *and their elements.
      */
     public class TopologyPersister {
     	public static void persist(Topology topology) {
+    	}
     	public static Topology load(Map storeParams) {
     		return null;
+    	}
+    }

     <?xml version="1.0" encoding="UTF-8"?>
     <projectDescription>
     	<name>libTopology</name>
     	<comment>@key 32303036313030362D31303030206C6962546F706F6C6F67792F416C7661726F205A6162616C61 </comment>
     	<projects>
     	</projects>
     	<buildSpec>
     		<buildCommand>
     			<name>org.eclipse.jdt.core.javabuilder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     		<buildCommand>
     			<name>com.omondo.uml.std.Builder</name>
     			<arguments>
     			</arguments>
     		</buildCommand>
     	</buildSpec>
     	<natures>
     		<nature>org.eclipse.jdt.core.javanature</nature>
     		<nature>com.omondo.uml.std.Nature</nature>
     	</natures>
     </projectDescription>

| gvSIG desktop 1

Revision 13263