Context Navigation

josm

Timestamp:

2013-09-21T00:10:46+02:00 (11 years ago)

Author:

Don-vip

Message:

fix more warnings/javadoc in data.validation.tests

Location:

trunk/src/org/openstreetmap/josm/data/validation/tests

Files:

-              r6240
+              r6241
+    }
+    /**
+     * Returns the list of "duplicate nodes" errors for the given selection of node and parent test
+     * @param parentTest The parent test of returned errors
+     * @param nodes The nodes selction to look into
+     * @return the list of "duplicate nodes" errors
+     */
     public List<TestError> buildTestErrors(Test parentTest, List<Node> nodes) {
         List<TestError> errors = new ArrayList<TestError>();

-              r5287
+              r6241
 import org.openstreetmap.josm.data.validation.TestError;
+/**
+ * Checks for ways with identical consecutive nodes.
+ * @since 3669
+ */
 public class DuplicatedWayNodes extends Test {
     protected static final int DUPLICATE_WAY_NODE = 501;
+    /**
+     * Constructs a new {@code DuplicatedWayNodes} test.
+     */
     public DuplicatedWayNodes() {
         super(tr("Duplicated way nodes"),

-              r6069
+              r6241
     protected static final int NODE_DUPING_PARENT_WAY_TAGS = 2401;
+    /**
+     * Constructs a new {@code NodesDuplicatingWayTags} test.
+     */
     public NodesDuplicatingWayTags() {
         super(tr("Nodes duplicating way tags"),

-              r6089
+              r6241
 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+/**
+ * Finds nodes that have the same name (might be duplicates)
+ * @since 3669
+ */
 public class NodesWithSameName extends Test {
     protected static final int SAME_NAME = 801;
 …
     private Map<String, List<Node>> namesToNodes;
+    /**
+     * Constructs a new {@code NodesWithSameName} test.
+     */
     public NodesWithSameName() {
         super(tr("Nodes with same name"),

-              r5927
+              r6241
 import org.openstreetmap.josm.tools.Utils;
+/**
+ * Checks if areas overlap.
+ * @since 4448
+ */
 public class OverlappingAreas extends Test {
 …
     protected QuadBuckets<Way> index = new QuadBuckets<Way>();
+    /**
+     * Constructs a new {@code OverlappingAreas} test.
+     */
     public OverlappingAreas() {
         super(tr("Overlapping Areas"), tr("This test checks if areas overlap."));

-              r6240
+              r6241
     protected static final int POWER_LINES = 2501;
+    /** Values for {@code power} key interpreted as power lines */
     public static final Collection<String> POWER_LINE_TAGS = Arrays.asList("line", "minor_line");
+    /** Values for {@code power} key interpreted as power towers */
     public static final Collection<String> POWER_TOWER_TAGS = Arrays.asList("tower", "pole");
+    /** Values for {@code power} key interpreted as power stations */
     public static final Collection<String> POWER_STATION_TAGS = Arrays.asList("station", "sub_station", "plant", "generator");
+    /** Values for {@code power} key interpreted as allowed power items */
     public static final Collection<String> POWER_ALLOWED_TAGS = Arrays.asList("switch", "transformer", "busbar", "generator");

-              r6240
+              r6241
         private Collection<Node> nodes = new LinkedList<Node>();
         private Collection<Way> ways = new LinkedList<Way>();
-        private Collection<Way> closedways = new LinkedList<Way>();
         private Collection<Way> openways = new LinkedList<Way>();
         private Collection<Relation> relations = new LinkedList<Relation>();
 …
                 } else if(m.isWay()) {
                     ri.ways.add(m.getWay());
+                    if (m.getWay().isClosed()) {
+                        ri.closedways.add(m.getWay());
+                    } else {
+                    if (!m.getWay().isClosed()) {
                         ri.openways.add(m.getWay());
+                    }

-              r4869
+              r6241
     protected static final int SELF_INTERSECT = 401;
+    /**
+     * Constructs a new {@code SelfIntersectingWay} test.
+     */
     public SelfIntersectingWay() {
         super(tr("Self-intersecting ways"),

-              r6069
+              r6241
 import org.openstreetmap.josm.data.validation.TestError;
+/**
+ * Checks if turnrestrictions are valid
+ * @since 3669
+ */
 public class TurnrestrictionTest extends Test {
 …
     protected static final int SUPERFLUOUS = 1815;
+    /**
+     * Constructs a new {@code TurnrestrictionTest}.
+     */
     public TurnrestrictionTest() {
         super(tr("Turnrestrictions"), tr("This test checks if turnrestrictions are valid"));

-              r6240
+              r6241
 import org.openstreetmap.josm.data.coor.LatLon;
 import org.openstreetmap.josm.data.osm.BBox;
-import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmUtils;
 …
     private Set<Node> othernodes; // nodes appearing at least twice
     private Area dsArea;
-    private DataSet ds;
     private double mindist;
 …
         mindist = Main.pref.getDouble(PREFIX + ".node_way_distance", 10.0);
         minmiddledist = Main.pref.getDouble(PREFIX + ".way_way_distance", 0.0);
+        this.ds = Main.main.getCurrentDataSet();
+        this.dsArea = ds.getDataSourceArea();
+        this.dsArea = Main.main.getCurrentDataSet().getDataSourceArea();
+    }

-              r5927
+              r6241
 import org.openstreetmap.josm.gui.mappaint.ElemStyles;
+/**
+ * Checks for ways connected to areas.
+ * @since 4682
+ */
 public class WayConnectedToArea extends Test {
+    /**
+     * Constructs a new {@code WayConnectedToArea} test.
+     */
     public WayConnectedToArea() {
         super(tr("Way connected to Area"), tr("Checks for ways connected to areas."));

Note: See TracChangeset for help on using the changeset viewer.